wip

236 files changed, 10088 insertions, 0 deletions

diff --git a/learn-you-some-erlang/LICENSE.txt b/learn-you-some-erlang/LICENSE.txt
new file mode 100644
index 0000000..5be26d9
--- /dev/null
+++ b/learn-you-some-erlang/LICENSE.txt
@@ -0,0 +1,22 @@
+Copyright (c) 2009 Frederic Trottier-Hebert
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/learn-you-some-erlang/README.txt b/learn-you-some-erlang/README.txt
new file mode 100644
index 0000000..d46e598
--- /dev/null
+++ b/learn-you-some-erlang/README.txt
@@ -0,0 +1,17 @@
+Man there's not a lot to write in a readme for such a book.
+
+You can get the license info in LICENSE.TXT (hint: it's the MIT license).
+I probably won't copy it in every module. Just pretend it's there, please.
+
+The code in these files has been tested with Erlang releases R13B+. In case you're not sure it will run on another version, you can run the tests yourself by compiling tester.erl and then calling:
+
+1> tester:dir().
+or
+2> tester:dir("/modules/path","/unit/tests/modules/path/").
+
+Which should run all the tests. If you're using the release R13B, there is a patch you need to apply in order to have unit tests running (see http://erlang.org/download.html).
+
+Note that even if the tests run fine, you'd benefit in using releases R13B+.
+
+If you need any more help, don't hesitate contacting me: mononcqc@ferd.ca.
+
diff --git a/learn-you-some-erlang/band_supervisor.erl b/learn-you-some-erlang/band_supervisor.erl
new file mode 100644
index 0000000..dd17ba8
--- /dev/null
+++ b/learn-you-some-erlang/band_supervisor.erl
@@ -0,0 +1,41 @@
+-module(band_supervisor).
+-behaviour(supervisor).
+
+-export([start_link/1]).
+-export([init/1]).
+
+start_link(Type) ->
+    supervisor:start_link({local,?MODULE}, ?MODULE, Type).
+
+%% The band supervisor will allow its band members to make a few
+%% mistakes before shutting down all operations, based on what
+%% mood he's in. A lenient supervisor will tolerate more mistakes
+%% than an angry supervisor, who'll tolerate more than a
+%% complete jerk supervisor
+init(lenient) ->
+    init({one_for_one, 3, 60});
+init(angry) ->
+    init({rest_for_one, 2, 60});
+init(jerk) ->
+    init({one_for_all, 1, 60});
+init(jamband) ->
+    {ok, {{simple_one_for_one, 3, 60},
+         [{jam_musician,
+           {musicians, start_link, []},
+           temporary, 1000, worker, [musicians]}
+         ]}};
+init({RestartStrategy, MaxRestart, MaxTime}) ->
+    {ok, {{RestartStrategy, MaxRestart, MaxTime},
+         [{singer,
+           {musicians, start_link, [singer, good]},
+           permanent, 1000, worker, [musicians]},
+          {bass,
+           {musicians, start_link, [bass, good]},
+           temporary, 1000, worker, [musicians]},
+          {drum,
+           {musicians, start_link, [drum, bad]},
+           transient, 1000, worker, [musicians]},
+          {keytar,
+           {musicians, start_link, [keytar, good]},
+           transient, 1000, worker, [musicians]}
+         ]}}.
diff --git a/learn-you-some-erlang/calc.erl b/learn-you-some-erlang/calc.erl
new file mode 100644
index 0000000..c41ffb6
--- /dev/null
+++ b/learn-you-some-erlang/calc.erl
@@ -0,0 +1,51 @@
+-module(calc).
+-export([rpn/1, rpn_test/0]).
+
+%% rpn(List()) -> Int() | Float()
+%% parses an RPN string and outputs the results.
+rpn(L) when is_list(L) ->
+    [Res] = lists:foldl(fun rpn/2, [], string:tokens(L, " ")),
+    Res.
+
+%% rpn(Str(), List()) -> List()
+%% Returns the new stack after an operation has been done.
+%% If no operator is found, we assume a number.
+rpn("+", [N1,N2|S]) -> [N2+N1|S];
+rpn("-", [N1,N2|S]) -> [N2-N1|S];
+rpn("*", [N1,N2|S]) -> [N2*N1|S];
+rpn("/", [N1,N2|S]) -> [N2/N1|S];
+rpn("^", [N1,N2|S]) -> [math:pow(N2,N1)|S];
+rpn("ln", [N|S])    -> [math:log(N)|S];
+rpn("log10", [N|S]) -> [math:log10(N)|S];
+rpn("sum", Stack)   -> [lists:sum(Stack)];
+rpn("prod", Stack)  -> [lists:foldl(fun erlang:'*'/2, 1, Stack)];
+rpn(X, Stack) -> [read(X)|Stack].
+
+%% read(String()) -> Int() | Float()
+read(N) ->
+    case string:to_float(N) of
+        {error,no_float} -> list_to_integer(N);
+        {F,_} -> F
+    end.
+
+%% returns 'ok' iff successful
+rpn_test() ->
+    5 = rpn("2 3 +"),
+    87 = rpn("90 3 -"),
+    -4 = rpn("10 4 3 + 2 * -"),
+    -2.0 = rpn("10 4 3 + 2 * - 2 /"),
+    ok = try
+        rpn("90 34 12 33 55 66 + * - +")
+    catch
+        error:{badmatch,[_|_]} -> ok
+    end,
+    4037 = rpn("90 34 12 33 55 66 + * - + -"),
+    8.0 =  rpn("2 3 ^"),
+    true = math:sqrt(2) == rpn("2 0.5 ^"),
+    true = math:log(2.7) == rpn("2.7 ln"),
+    true = math:log10(2.7) == rpn("2.7 log10"),
+    50 = rpn("10 10 10 20 sum"),
+    10.0 = rpn("10 10 10 20 sum 5 /"),
+    1000.0 = rpn("10 10 20 0.5 prod"),
+    ok.
+
diff --git a/learn-you-some-erlang/cards.erl b/learn-you-some-erlang/cards.erl
new file mode 100644
index 0000000..ee8dcd2
--- /dev/null
+++ b/learn-you-some-erlang/cards.erl
@@ -0,0 +1,16 @@
+-module(cards).
+-export([kind/1, main/0]).
+
+-type suit() :: spades | clubs | hearts | diamonds.
+-type value() :: 1..10 | j | q | k.
+-type card() :: {suit(), value()}.
+
+-spec kind(card()) -> face | number.
+kind({_, A}) when A >= 1, A =< 10 -> number;
+kind(_) -> face.
+
+main() ->
+    number = kind({spades, 7}),
+    face   = kind({hearts, k}),
+    number = kind({rubies, 4}),
+    face   = kind({clubs, q}).
diff --git a/learn-you-some-erlang/cases.erl b/learn-you-some-erlang/cases.erl
new file mode 100644
index 0000000..9b4f931
--- /dev/null
+++ b/learn-you-some-erlang/cases.erl
@@ -0,0 +1,22 @@
+-module(cases).
+-export([insert/2,beach/1]).
+
+insert(X,[]) ->
+    [X];
+insert(X,Set) ->
+    case lists:member(X,Set) of
+        true  -> Set;
+        false -> [X|Set]
+    end.
+
+beach(Temperature) ->
+    case Temperature of
+        {celsius, N} when N >= 20, N =< 45 ->
+            'favorable';
+        {kelvin, N} when N >= 293, N =< 318 ->
+            'scientifically favorable';
+        {fahrenheit, N} when N >= 68, N =< 113 ->
+            'favorable in the US';
+        _ ->
+            'avoid beach'
+    end.
diff --git a/learn-you-some-erlang/cat_fsm.erl b/learn-you-some-erlang/cat_fsm.erl
new file mode 100644
index 0000000..3fa5039
--- /dev/null
+++ b/learn-you-some-erlang/cat_fsm.erl
@@ -0,0 +1,23 @@
+-module(cat_fsm).
+-export([start/0, event/2]).
+
+start() ->
+	spawn(fun() -> dont_give_crap() end).
+
+event(Pid, Event) ->
+	Ref = make_ref(), % won't care for monitors here
+	Pid ! {self(), Ref, Event},
+	receive
+		{Ref, Msg} -> {ok, Msg}
+	after 5000 ->
+		{error, timeout}
+	end.
+
+dont_give_crap() ->
+	receive
+		{Pid, Ref, _Msg} -> Pid ! {Ref, meh};
+		_ -> ok
+	end,
+	io:format("Switching to 'dont_give_crap' state~n"),
+	dont_give_crap().
+
diff --git a/learn-you-some-erlang/convert.erl b/learn-you-some-erlang/convert.erl
new file mode 100644
index 0000000..86c3c2b
--- /dev/null
+++ b/learn-you-some-erlang/convert.erl
@@ -0,0 +1,14 @@
+-module(convert).
+-export([main/0, convert/1]).
+
+main() ->
+    [_,_] = convert({a,b}),
+    {_,_} = convert([a,b]),
+    [_,_] = convert([a,b]),
+    {_,_} = convert({a,b}).
+
+-spec convert(tuple()) -> list()
+      ;      (list()) -> tuple().
+convert(Tup) when is_tuple(Tup) -> tuple_to_list(Tup);
+convert(L = [_|_]) -> list_to_tuple(L).
+
diff --git a/learn-you-some-erlang/ct/demo/basic_SUITE.erl b/learn-you-some-erlang/ct/demo/basic_SUITE.erl
new file mode 100644
index 0000000..566ff54
--- /dev/null
+++ b/learn-you-some-erlang/ct/demo/basic_SUITE.erl
@@ -0,0 +1,13 @@
+-module(basic_SUITE).
+-include_lib("common_test/include/ct.hrl").
+-export([all/0]).
+-export([test1/1, test2/1]).
+
+all() -> [test1,test2].
+
+test1(_Config) ->
+    1 = 1.
+
+test2(_Config) ->
+    A = 0,
+    1/A.
diff --git a/learn-you-some-erlang/ct/demo/state_SUITE.erl b/learn-you-some-erlang/ct/demo/state_SUITE.erl
new file mode 100644
index 0000000..3ee0e5b
--- /dev/null
+++ b/learn-you-some-erlang/ct/demo/state_SUITE.erl
@@ -0,0 +1,24 @@
+-module(state_SUITE).
+-include_lib("common_test/include/ct.hrl").
+
+-export([all/0, init_per_testcase/2, end_per_testcase/2]).
+-export([ets_tests/1]).
+
+all() -> [ets_tests].
+
+init_per_testcase(ets_tests, Config) ->
+    TabId = ets:new(account, [ordered_set, public]),
+    ets:insert(TabId, {andy, 2131}),
+    ets:insert(TabId, {david, 12}),
+    ets:insert(TabId, {steve, 12943752}),
+    [{table,TabId} | Config].
+
+end_per_testcase(ets_tests, Config) ->
+    ets:delete(?config(table, Config)).
+
+ets_tests(Config) ->
+    TabId = ?config(table, Config),
+    [{david, 12}] = ets:lookup(TabId, david),
+    steve = ets:last(TabId),
+    true = ets:insert(TabId, {zachary, 99}),
+    zachary = ets:last(TabId).
diff --git a/learn-you-some-erlang/ct/dist.spec b/learn-you-some-erlang/ct/dist.spec
new file mode 100644
index 0000000..e25cdfb
--- /dev/null
+++ b/learn-you-some-erlang/ct/dist.spec
@@ -0,0 +1,14 @@
+{node, a, 'a@ferdmbp.local'}.
+{node, b, 'b@ferdmbp.local'}.
+
+{init, [a,b], [{node_start, [{monitor_master, true}]}]}.
+
+{alias, demo, "/Users/ferd/code/self/learn-you-some-erlang/ct/demo/"}.
+{alias, meeting, "/Users/ferd/code/self/learn-you-some-erlang/ct/meeting/"}.
+
+{logdir, all_nodes, "/Users/ferd/code/self/learn-you-some-erlang/ct/logs/"}.
+{logdir, master, "/Users/ferd/code/self/learn-you-some-erlang/ct/logs/"}.
+
+{suites, [b], meeting, all}.
+{suites, [a], demo, all}.
+{skip_cases, [a], demo, basic_SUITE, test2, "This test fails on purpose"}.
diff --git a/learn-you-some-erlang/ct/meeting/meeting.erl b/learn-you-some-erlang/ct/meeting/meeting.erl
new file mode 100644
index 0000000..0de9453
--- /dev/null
+++ b/learn-you-some-erlang/ct/meeting/meeting.erl
@@ -0,0 +1,45 @@
+-module(meeting).
+-export([rent_projector/1, use_chairs/1, book_room/1,
+        get_all_bookings/0, start/0, stop/0]).
+-record(bookings, {projector, room, chairs}).
+
+start() ->
+    Pid = spawn(fun() -> loop(#bookings{}) end),
+    register(?MODULE, Pid).
+
+stop() ->
+    ?MODULE ! stop.
+
+rent_projector(Group) ->
+    ?MODULE ! {projector, Group}.
+
+book_room(Group) ->
+    ?MODULE ! {room, Group}.
+
+use_chairs(Group) ->
+    ?MODULE ! {chairs, Group}.
+
+get_all_bookings() ->
+    Ref = make_ref(),
+    ?MODULE ! {self(), Ref, get_bookings},
+    receive
+        {Ref, Reply} ->
+            Reply
+    end.
+
+loop(B = #bookings{}) ->
+    receive
+        stop -> ok;
+        {From, Ref, get_bookings} ->
+            From ! {Ref, [{room, B#bookings.room},
+                          {chairs, B#bookings.chairs},
+                          {projector, B#bookings.projector}]},
+            loop(B);
+        {room, Group} ->
+            loop(B#bookings{room=Group});
+        {chairs, Group} ->
+            loop(B#bookings{chairs=Group});
+        {projector, Group} ->
+            loop(B#bookings{projector=Group})
+    end.
+
diff --git a/learn-you-some-erlang/ct/meeting/meeting_SUITE.erl b/learn-you-some-erlang/ct/meeting/meeting_SUITE.erl
new file mode 100755
index 0000000..f699569
--- /dev/null
+++ b/learn-you-some-erlang/ct/meeting/meeting_SUITE.erl
@@ -0,0 +1,51 @@
+-module(meeting_SUITE).
+-include_lib("common_test/include/ct.hrl").
+-export([all/0, groups/0, init_per_group/2, end_per_group/2]).
+-export([carla/1, mark/1, dog/1, all_same_owner/1]).
+
+%% Regroup the tests as groups that will let you try to see if the 'meeting.erl'
+%% modules contains concurrency errors or not.
+
+all() -> [{group, session}].
+
+groups() -> [{session,
+              [],
+              [{group, clients}, all_same_owner]},
+             {clients,
+              [parallel, {repeat, 10}],
+              [carla, mark, dog]}].
+
+init_per_group(session, Config) ->
+    meeting:start(),
+    Config;
+init_per_group(_, Config) ->
+    Config.
+
+end_per_group(session, _Config) ->
+    meeting:stop();
+end_per_group(_, _Config) ->
+    ok.
+
+carla(_Config) ->
+    meeting:book_room(women),
+    timer:sleep(10),
+    meeting:rent_projector(women),
+    timer:sleep(10),
+    meeting:use_chairs(women).
+
+mark(_Config) ->
+    meeting:rent_projector(men),
+    timer:sleep(10),
+    meeting:use_chairs(men),
+    timer:sleep(10),
+    meeting:book_room(men).
+
+dog(_Config) ->
+    meeting:rent_projector(animals),
+    timer:sleep(10),
+    meeting:use_chairs(animals),
+    timer:sleep(10),
+    meeting:book_room(animals).
+
+all_same_owner(_Config) ->
+    [{_,Owner}, {_, Owner}, {_, Owner}] = meeting:get_all_bookings().
diff --git a/learn-you-some-erlang/ct/spec.spec b/learn-you-some-erlang/ct/spec.spec
new file mode 100644
index 0000000..1752664
--- /dev/null
+++ b/learn-you-some-erlang/ct/spec.spec
@@ -0,0 +1,7 @@
+{alias, demo, "./demo/"}.
+{alias, meeting, "./meeting/"}.
+{logdir, "./logs/"}.
+
+{suites, meeting, all}.
+{suites, demo, all}.
+{skip_cases, demo, basic_SUITE, test2, "This test fails on purpose"}.
diff --git a/learn-you-some-erlang/curling.erl b/learn-you-some-erlang/curling.erl
new file mode 100644
index 0000000..2c50074
--- /dev/null
+++ b/learn-you-some-erlang/curling.erl
@@ -0,0 +1,37 @@
+-module(curling).
+-export([start_link/2, set_teams/3, add_points/3, next_round/1]).
+-export([join_feed/2, leave_feed/2]).
+-export([game_info/1]).
+
+start_link(TeamA, TeamB) ->
+    {ok, Pid} = gen_event:start_link(),
+    %% The scoreboard will always be there
+    gen_event:add_handler(Pid, curling_scoreboard, []),
+    %% Start the stats accumulator
+    gen_event:add_handler(Pid, curling_accumulator, []),
+    set_teams(Pid, TeamA, TeamB),
+    {ok, Pid}.
+
+set_teams(Pid, TeamA, TeamB) ->
+    gen_event:notify(Pid, {set_teams, TeamA, TeamB}).
+
+add_points(Pid, Team, N) ->
+    gen_event:notify(Pid, {add_points, Team, N}).
+
+next_round(Pid) ->
+    gen_event:notify(Pid, next_round).
+
+%% Subscribes the pid ToPid to the event feed.
+%% The specific event handler for the newsfeed is
+%% returned in case someone wants to leave
+join_feed(Pid, ToPid) ->
+    HandlerId = {curling_feed, make_ref()},
+    gen_event:add_sup_handler(Pid, HandlerId, [ToPid]),
+    HandlerId.
+
+leave_feed(Pid, HandlerId) ->
+    gen_event:delete_handler(Pid, HandlerId, leave_feed).
+
+%% Returns the current game state.
+game_info(Pid) ->
+    gen_event:call(Pid, curling_accumulator, game_data).
diff --git a/learn-you-some-erlang/curling_accumulator.erl b/learn-you-some-erlang/curling_accumulator.erl
new file mode 100644
index 0000000..f6cacfd
--- /dev/null
+++ b/learn-you-some-erlang/curling_accumulator.erl
@@ -0,0 +1,35 @@
+-module(curling_accumulator).
+-behaviour(gen_event).
+
+-export([init/1, handle_event/2, handle_call/2, handle_info/2, code_change/3,
+         terminate/2]).
+
+-record(state, {teams=orddict:new(), round=0}).
+
+init([]) ->
+    {ok, #state{}}.
+
+handle_event({set_teams, TeamA, TeamB}, S=#state{teams=T}) ->
+    Teams = orddict:store(TeamA, 0, orddict:store(TeamB, 0, T)),
+    {ok, S#state{teams=Teams}};
+handle_event({add_points, Team, N}, S=#state{teams=T}) ->
+    Teams = orddict:update_counter(Team, N, T),
+    {ok, S#state{teams=Teams}};
+handle_event(next_round, S=#state{}) ->
+    {ok, S#state{round = S#state.round+1}};
+handle_event(_Event, Pid) ->
+    {ok, Pid}.
+
+handle_call(game_data, S=#state{teams=T, round=R}) ->
+    {ok, {orddict:to_list(T), {round, R}}, S};
+handle_call(_, State) ->
+    {ok, ok, State}.
+
+handle_info(_, State) ->
+    {ok, State}.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+terminate(_Reason, _State) ->
+    ok.
diff --git a/learn-you-some-erlang/curling_feed.erl b/learn-you-some-erlang/curling_feed.erl
new file mode 100644
index 0000000..b1b789a
--- /dev/null
+++ b/learn-you-some-erlang/curling_feed.erl
@@ -0,0 +1,24 @@
+-module(curling_feed).
+-behaviour(gen_event).
+
+-export([init/1, handle_event/2, handle_call/2, handle_info/2, code_change/3,
+         terminate/2]).
+
+init([Pid]) ->
+    {ok, Pid}.
+
+handle_event(Event, Pid) ->
+    Pid ! {curling_feed, Event},
+    {ok, Pid}.
+
+handle_call(_, State) ->
+    {ok, ok, State}.
+
+handle_info(_, State) ->
+    {ok, State}.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+terminate(_Reason, _State) ->
+    ok.
diff --git a/learn-you-some-erlang/curling_scoreboard.erl b/learn-you-some-erlang/curling_scoreboard.erl
new file mode 100644
index 0000000..34ff48d
--- /dev/null
+++ b/learn-you-some-erlang/curling_scoreboard.erl
@@ -0,0 +1,32 @@
+-module(curling_scoreboard).
+-behaviour(gen_event).
+
+-export([init/1, handle_event/2, handle_call/2, handle_info/2, code_change/3,
+         terminate/2]).
+
+init([]) ->
+    {ok, []}.
+
+handle_event({set_teams, TeamA, TeamB}, State) ->
+    curling_scoreboard_hw:set_teams(TeamA, TeamB),
+    {ok, State};
+handle_event({add_points, Team, N}, State) ->
+    [curling_scoreboard_hw:add_point(Team) || _ <- lists:seq(1,N)],
+    {ok, State};
+handle_event(next_round, State) ->
+    curling_scoreboard_hw:next_round(),
+    {ok, State};
+handle_event(_, State) ->
+    {ok, State}.
+
+handle_call(_, State) ->
+    {ok, ok, State}.
+
+handle_info(_, State) ->
+    {ok, State}.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+terminate(_Reason, _State) ->
+    ok.
diff --git a/learn-you-some-erlang/curling_scoreboard_hw.erl b/learn-you-some-erlang/curling_scoreboard_hw.erl
new file mode 100644
index 0000000..adfe4ab
--- /dev/null
+++ b/learn-you-some-erlang/curling_scoreboard_hw.erl
@@ -0,0 +1,19 @@
+-module(curling_scoreboard_hw).
+-export([add_point/1, next_round/0, set_teams/2, reset_board/0]).
+
+%% This is a 'dumb' module that's only there to replace what a real hardware
+%% controller would likely do. The real hardware controller would likely hold
+%% some state and make sure everything works right, but this one doesn't mind.
+
+%% Shows the teams on the scoreboard.
+set_teams(TeamA, TeamB) ->
+    io:format("Scoreboard: Team ~s vs. Team ~s~n", [TeamA, TeamB]).
+
+next_round() ->
+    io:format("Scoreboard: round over~n").
+
+add_point(Team) ->
+    io:format("Scoreboard: increased score of team ~s by 1~n", [Team]).
+
+reset_board() ->
+    io:format("Scoreboard: All teams are undefined and all scores are 0~n").
diff --git a/learn-you-some-erlang/discrep1.erl b/learn-you-some-erlang/discrep1.erl
new file mode 100644
index 0000000..188e938
--- /dev/null
+++ b/learn-you-some-erlang/discrep1.erl
@@ -0,0 +1,6 @@
+-module(discrep1).
+-export([run/0]).
+
+run() -> some_op(5, you).
+
+some_op(A, B) -> A + B.
diff --git a/learn-you-some-erlang/discrep2.erl b/learn-you-some-erlang/discrep2.erl
new file mode 100644
index 0000000..7462e5f
--- /dev/null
+++ b/learn-you-some-erlang/discrep2.erl
@@ -0,0 +1,12 @@
+-module(discrep2).
+-export([run/0]).
+
+run() ->
+    Tup = money(5, you),
+    some_op(count(Tup), account(Tup)).
+
+money(Num, Name) -> {give, Num, Name}.
+count({give, Num, _}) -> Num.
+account({give, _, X}) -> X.
+
+some_op(A, B) -> A + B.
diff --git a/learn-you-some-erlang/discrep3.erl b/learn-you-some-erlang/discrep3.erl
new file mode 100644
index 0000000..aaec5d6
--- /dev/null
+++ b/learn-you-some-erlang/discrep3.erl
@@ -0,0 +1,14 @@
+-module(discrep3).
+-export([run/0]).
+
+run() ->
+    Tup = money(5, you),
+    some_op(item(count, Tup), item(account, Tup)).
+
+money(Num, Name) -> {give, Num, Name}.
+
+item(count, {give, X, _}) -> X;
+item(account, {give, _, X}) -> X.
+
+some_op(A, B) -> A + B.
+
diff --git a/learn-you-some-erlang/discrep4.erl b/learn-you-some-erlang/discrep4.erl
new file mode 100644
index 0000000..949a843
--- /dev/null
+++ b/learn-you-some-erlang/discrep4.erl
@@ -0,0 +1,21 @@
+-module(discrep4).
+-export([run/0]).
+-type cents() :: integer().
+-type account() :: atom().
+-type transaction() :: {'give', cents(), account()}.
+
+run() ->
+    Tup = money(5, you),
+    some_op(item(count,Tup), item(account,Tup)).
+
+-spec money(cents(), account()) -> transaction().
+money(Num, Name) -> {give, Num, Name}.
+
+-spec item('count', transaction()) -> cents();
+          ('account', transaction()) -> account().
+item(count, {give, X, _}) -> X;
+item(account, {give, _, X}) -> X.
+
+some_op(A,B) -> A + B.
+
+
diff --git a/learn-you-some-erlang/dog_fsm.erl b/learn-you-some-erlang/dog_fsm.erl
new file mode 100644
index 0000000..f784933
--- /dev/null
+++ b/learn-you-some-erlang/dog_fsm.erl
@@ -0,0 +1,42 @@
+-module(dog_fsm).
+-export([start/0, squirrel/1, pet/1]).
+
+start() -> spawn(fun() -> bark() end).
+
+squirrel(Pid) -> Pid ! squirrel.
+
+pet(Pid) -> Pid ! pet.
+
+bark() ->
+    io:format("Dog says: BARK! BARK!~n"),
+    receive
+        pet ->
+            wag_tail();
+        _ ->
+            io:format("Dog is confused~n"),
+            bark()
+    after 2000 ->
+        bark()
+    end.
+            
+wag_tail() ->
+    io:format("Dog wags its tail~n"),
+    receive
+        pet ->
+            sit();
+        _ ->
+            io:format("Dog is confused~n"),
+            wag_tail()
+    after 30000 ->
+        bark()
+    end.
+
+sit() ->
+    io:format("Dog is sitting. Gooooood boy!~n"),
+    receive
+        squirrel ->
+            bark();
+        _ ->
+            io:format("Dog is confused~n"),
+            sit()
+    end.
diff --git a/learn-you-some-erlang/dolphins.erl b/learn-you-some-erlang/dolphins.erl
new file mode 100644
index 0000000..1e84b77
--- /dev/null
+++ b/learn-you-some-erlang/dolphins.erl
@@ -0,0 +1,34 @@
+-module(dolphins).
+-compile(export_all).
+
+dolphin1() ->
+    receive
+        do_a_flip ->
+            io:format("How about no?~n");
+        fish ->
+            io:format("So long and thanks for all the fish!~n");
+        _ ->
+            io:format("Heh, we're smarter than you humans.~n")
+    end.
+
+dolphin2() ->
+    receive
+        {From, do_a_flip} ->
+            From ! "How about no?";
+        {From, fish} ->
+            From ! "So long and thanks for all the fish!";
+        _ ->
+            io:format("Heh, we're smarter than you humans.~n")
+    end.
+
+dolphin3() ->
+    receive
+        {From, do_a_flip} ->
+            From ! "How about no?",
+            dolphin3();
+        {From, fish} ->
+            From ! "So long and thanks for all the fish!";
+        _ ->
+            io:format("Heh, we're smarter than you humans.~n"),
+            dolphin3()
+    end.
diff --git a/learn-you-some-erlang/erlcount-1.0/Emakefile b/learn-you-some-erlang/erlcount-1.0/Emakefile
new file mode 100644
index 0000000..76e98fc
--- /dev/null
+++ b/learn-you-some-erlang/erlcount-1.0/Emakefile
@@ -0,0 +1,4 @@
+{"src/*", [debug_info, {i,"include/"}, {outdir, "ebin/"}]}.
+%% The TESTDIR macro assumes the file is running from the 'erlcount-1.0'
+%% directory, sitting within 'learn-you-some-erlang/'.
+{"test/*", [debug_info, {i,"include/"}, {outdir, "ebin/"}, {d, 'TESTDIR', ".."}]}.
diff --git a/learn-you-some-erlang/erlcount-1.0/ebin/erlcount.app b/learn-you-some-erlang/erlcount-1.0/ebin/erlcount.app
new file mode 100644
index 0000000..1d40c4b
--- /dev/null
+++ b/learn-you-some-erlang/erlcount-1.0/ebin/erlcount.app
@@ -0,0 +1,13 @@
+{application, erlcount,
+ [{vsn, "1.0.0"},
+  {modules, [erlcount, erlcount_sup, erlcount_lib,
+             erlcount_dispatch, erlcount_counter]},
+  {applications, [ppool]},
+  {registered, [erlcount]},
+  {mod, {erlcount, []}},
+  {env,
+   [{directory, "."},
+    {regex, ["if\\s.+->", "case\\s.+\\sof"]},
+    {max_files, 10}]}
+ ]}.
+
diff --git a/learn-you-some-erlang/erlcount-1.0/src/erlcount.erl b/learn-you-some-erlang/erlcount-1.0/src/erlcount.erl
new file mode 100644
index 0000000..16a9f23
--- /dev/null
+++ b/learn-you-some-erlang/erlcount-1.0/src/erlcount.erl
@@ -0,0 +1,9 @@
+-module(erlcount).
+-behaviour(application).
+-export([start/2, stop/1]).
+
+start(normal, _Args) ->
+    erlcount_sup:start_link().
+
+stop(_State) ->
+    ok.
diff --git a/learn-you-some-erlang/erlcount-1.0/src/erlcount_counter.erl b/learn-you-some-erlang/erlcount-1.0/src/erlcount_counter.erl
new file mode 100644
index 0000000..c42fd4d
--- /dev/null
+++ b/learn-you-some-erlang/erlcount-1.0/src/erlcount_counter.erl
@@ -0,0 +1,35 @@
+-module(erlcount_counter).
+-behaviour(gen_server).
+-export([start_link/4]).
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+        terminate/2, code_change/3]).
+
+-record(state, {dispatcher, ref, file, re}).
+
+start_link(DispatcherPid, Ref, FileName, Regex) ->
+    gen_server:start_link(?MODULE, [DispatcherPid, Ref, FileName, Regex], []).
+
+init([DispatcherPid, Ref, FileName, Regex]) ->
+    self() ! start,
+    {ok, #state{dispatcher=DispatcherPid,
+                ref = Ref,
+                file = FileName,
+                re = Regex}}.
+
+handle_call(_Msg, _From, State) ->
+    {noreply, State}.
+
+handle_cast(_Msg, State) ->
+    {noreply, State}.
+
+handle_info(start, S = #state{re=Re, ref=Ref}) ->
+    {ok, Bin} = file:read_file(S#state.file),
+    Count = erlcount_lib:regex_count(Re, Bin),
+    erlcount_dispatch:complete(S#state.dispatcher, Re, Ref, Count),
+    {stop, normal, S}.
+
+terminate(_Reason, _State) ->
+    ok.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
diff --git a/learn-you-some-erlang/erlcount-1.0/src/erlcount_dispatch.erl b/learn-you-some-erlang/erlcount-1.0/src/erlcount_dispatch.erl
new file mode 100644
index 0000000..0bc5e45
--- /dev/null
+++ b/learn-you-some-erlang/erlcount-1.0/src/erlcount_dispatch.erl
@@ -0,0 +1,86 @@
+-module(erlcount_dispatch).
+-behaviour(gen_fsm).
+-export([start_link/0, complete/4]).
+-export([init/1, dispatching/2, listening/2, handle_event/3,
+        handle_sync_event/4, handle_info/3, terminate/3, code_change/4]).
+
+-define(POOL, erlcount).
+-record(data, {regex=[], refs=[]}).
+
+%%% PUBLIC API
+start_link() ->
+    gen_fsm:start_link(?MODULE, [], []).
+
+complete(Pid, Regex, Ref, Count) ->
+    gen_fsm:send_all_state_event(Pid, {complete, Regex, Ref, Count}).
+
+%%% GEN_FSM
+%% Two states: dispatching and listening
+init([]) ->
+    %% Move the get_env stuff to the supervisor's init.
+    {ok, Re} = application:get_env(regex),
+    {ok, Dir} = application:get_env(directory),
+    {ok, MaxFiles} = application:get_env(max_files),
+    ppool:start_pool(?POOL, MaxFiles, {erlcount_counter, start_link, []}),
+    case lists:all(fun valid_regex/1, Re) of
+        true ->
+            %% creates a regex entry of the form [{Re, Count}]
+            self() ! {start, Dir},
+            {ok, dispatching, #data{regex=[{R,0} || R <- Re]}};
+        false ->
+           {stop, invalid_regex}
+    end.
+
+dispatching({continue, File, Continuation}, Data = #data{regex=Re, refs=Refs}) ->
+    F = fun({Regex,_Count}, NewRefs) ->
+        Ref = make_ref(),
+        ppool:async_queue(?POOL, [self(), Ref, File, Regex]),
+        [Ref|NewRefs]
+    end,
+    NewRefs = lists:foldl(F, Refs, Re),
+    gen_fsm:send_event(self(), Continuation()),
+    {next_state, dispatching, Data#data{refs = NewRefs}};
+dispatching(done, Data) ->
+    %% This is a special case. We can not assume that all messages have NOT
+    %% been received by the time we hit 'done'. As such, we directly move to
+    %% listening/2 without waiting for an external event.
+    listening(done, Data).
+
+listening(done, #data{regex=Re, refs=[]}) -> % all received!
+    [io:format("Regex ~s has ~p results~n", [R,C]) || {R, C} <- Re],
+    {stop, normal, done};
+listening(done, Data) -> % entries still missing
+    {next_state, listening, Data}.
+
+handle_event({complete, Regex, Ref, Count}, State, Data = #data{regex=Re, refs=Refs}) ->
+    {Regex, OldCount} = lists:keyfind(Regex, 1, Re),
+    NewRe = lists:keyreplace(Regex, 1, Re, {Regex, OldCount+Count}),
+    NewData = Data#data{regex=NewRe, refs=Refs--[Ref]},
+    case State of
+        dispatching ->
+            {next_state, dispatching, NewData};
+        listening ->
+            listening(done, NewData)
+    end.
+
+handle_sync_event(Event, _From, State, Data) ->
+    io:format("Unexpected event: ~p~n", [Event]),
+    {next_state, State, Data}.
+
+handle_info({start, Dir}, State, Data) ->
+    gen_fsm:send_event(self(), erlcount_lib:find_erl(Dir)),
+    {next_state, State, Data}.
+
+terminate(_Reason, _State, _Data) ->
+    ok.
+
+code_change(_OldVsn, State, Data, _Extra) ->
+    {ok, State, Data}.
+
+%%% PRIVATE 
+valid_regex(Re) ->
+    try re:run("", Re) of
+        _ -> true
+    catch
+        error:badarg -> false
+    end.
diff --git a/learn-you-some-erlang/erlcount-1.0/src/erlcount_lib.erl b/learn-you-some-erlang/erlcount-1.0/src/erlcount_lib.erl
new file mode 100644
index 0000000..70c062f
--- /dev/null
+++ b/learn-you-some-erlang/erlcount-1.0/src/erlcount_lib.erl
@@ -0,0 +1,55 @@
+-module(erlcount_lib).
+-export([find_erl/1, regex_count/2]).
+-include_lib("kernel/include/file.hrl").
+
+%% Finds all files ending in .erl
+find_erl(Directory) ->
+    find_erl(Directory, queue:new()).
+
+regex_count(Re, Str) ->
+    case re:run(Str, Re, [global]) of
+        nomatch -> 0;
+        {match, List} -> length(List)
+    end.
+
+%%% Private
+%% Dispatches based on file type
+find_erl(Name, Queue) ->
+    {ok, F = #file_info{}} = file:read_file_info(Name),
+    case F#file_info.type of
+        directory -> handle_directory(Name, Queue);
+        regular -> handle_regular_file(Name, Queue);
+        _Other -> dequeue_and_run(Queue)
+    end.
+
+%% Opens directories and enqueues files in there
+handle_directory(Dir, Queue) ->
+    case file:list_dir(Dir) of
+        {ok, []} ->
+            dequeue_and_run(Queue);
+        {ok, Files} ->
+            dequeue_and_run(enqueue_many(Dir, Files, Queue))
+    end.
+
+%% Checks if the file finishes in .erl
+handle_regular_file(Name, Queue) ->
+    case filename:extension(Name) of
+        ".erl" ->
+            {continue, Name, fun() -> dequeue_and_run(Queue) end};
+        _NonErl ->
+            dequeue_and_run(Queue)
+    end.
+
+%% Pops an item from the queue and runs it.
+dequeue_and_run(Queue) ->
+    case queue:out(Queue) of
+        {empty, _} -> done;
+        {{value, File}, NewQueue} -> find_erl(File, NewQueue)
+    end.
+
+%% Adds a bunch of items to the queue.
+enqueue_many(Path, Files, Queue) ->
+    F = fun(File, Q) -> queue:in(filename:join(Path,File), Q) end,
+    lists:foldl(F, Queue, Files).
+
+
diff --git a/learn-you-some-erlang/erlcount-1.0/src/erlcount_sup.erl b/learn-you-some-erlang/erlcount-1.0/src/erlcount_sup.erl
new file mode 100644
index 0000000..b8633a3
--- /dev/null
+++ b/learn-you-some-erlang/erlcount-1.0/src/erlcount_sup.erl
@@ -0,0 +1,17 @@
+-module(erlcount_sup).
+-behaviour(supervisor).
+-export([start_link/0, init/1]).
+
+start_link() ->
+    supervisor:start_link(?MODULE, []).
+
+init([]) ->
+    MaxRestart = 5,
+    MaxTime = 100,
+    {ok, {{one_for_one, MaxRestart, MaxTime},
+     [{dispatch,
+       {erlcount_dispatch, start_link, []},
+        transient,
+        60000,
+        worker,
+        [erlcount_dispatch]}]}}.
diff --git a/learn-you-some-erlang/erlcount-1.0/test/erlcount_tests.erl b/learn-you-some-erlang/erlcount-1.0/test/erlcount_tests.erl
new file mode 100644
index 0000000..7459a39
--- /dev/null
+++ b/learn-you-some-erlang/erlcount-1.0/test/erlcount_tests.erl
@@ -0,0 +1,35 @@
+-module(erlcount_tests).
+-include_lib("eunit/include/eunit.hrl").
+-ifndef(TESTDIR).
+%% Assumes we're running from the app's directory. We want to target the
+%% 'learn-you-some-erlang' directory.
+-define(TESTDIR, "..").
+-endif.
+
+%% NOTE:
+%% Because we do not want the tests to be bound to a specific snapshot in time
+%% of our app, we will instead compare it to an oracle built with unix
+%% commands. Users running windows sadly won't be able to run these tests.
+
+%% We'll be forcing the design to be continuation-based when it comes to
+%% reading files. This will require some explaining to the user, but will
+%% allow to show how we can read files and schedule them at the same time,
+%% but without breaking functional principles of referential transparency
+%% and while allowing specialised functions to be written in a testable manner.
+find_erl_test_() ->
+    ?_assertEqual(lists:sort(string:tokens(os:cmd("find "++?TESTDIR++" -name *.erl"), "\n")),
+        lists:sort(build_list(erlcount_lib:find_erl(?TESTDIR)))).
+
+build_list(Term) -> build_list(Term, []).
+
+build_list(done, List) -> List;
+build_list({continue, Entry, Fun}, List) ->
+    build_list(Fun(), [Entry|List]).
+
+regex_count_test_() ->
+    [?_assertEqual(5, erlcount_lib:regex_count("a", "a a a a a")),
+     ?_assertEqual(0, erlcount_lib:regex_count("o", "a a a a a")),
+     ?_assertEqual(2, erlcount_lib:regex_count("a.*", "a a a\na a a")),
+     ?_assertEqual(3, erlcount_lib:regex_count("if", "myiffun() ->\n if 1 < \" if \" -> ok;\n    true -> other\n end.\n")),
+     ?_assertEqual(1, erlcount_lib:regex_count("if[\\s]{1}(?:.+)->", "myiffun() ->\n if 1 < \" if  \" -> ok;\n    true -> other\n end.\n")),
+     ?_assertEqual(2, erlcount_lib:regex_count("if[\\s]{1}(?:.+)->", "myiffun() ->\n if 1 < \" if  \" -> ok;\n    true -> other\n end,\n if true -> ok end.\n"))].
diff --git a/learn-you-some-erlang/exceptions.erl b/learn-you-some-erlang/exceptions.erl
new file mode 100644
index 0000000..0ed6742
--- /dev/null
+++ b/learn-you-some-erlang/exceptions.erl
@@ -0,0 +1,76 @@
+-module(exceptions).
+-compile(export_all).
+
+throws(F) ->
+    try F() of
+        _ -> ok
+    catch
+        Throw -> {throw, caught, Throw}
+    end.
+
+errors(F) ->
+    try F() of
+        _ -> ok
+    catch
+        error:Error -> {error, caught, Error}
+    end.
+
+exits(F) ->
+    try F() of
+        _ -> ok
+    catch
+        exit:Exit -> {exit, caught, Exit}
+    end.
+
+sword(1) -> throw(slice);
+sword(2) -> erlang:error(cut_arm);
+sword(3) -> exit(cut_leg);
+sword(4) -> throw(punch);
+sword(5) -> exit(cross_bridge).
+
+%%"I must cross this bridge"
+black_knight(Attack) when is_function(Attack, 0) ->
+    try Attack() of
+        _ -> "None shall pass."
+    catch
+        throw:slice -> "It is but a scratch.";
+        error:cut_arm -> "I've had worse.";
+        exit:cut_leg -> "Come on you pansy!";
+        _:_ -> "Just a flesh wound."
+    end.
+%"We'll call it a draw..."
+
+talk() -> "blah blah".
+
+whoa() ->
+    try
+        talk(),
+        _Knight = "None shall Pass!",
+        _Doubles = [N*2 || N <- lists:seq(1,100)],
+        throw(up),
+        _WillReturnThis = tequila
+    of
+        tequila -> "hey this worked!"
+    catch
+        Exception:Reason -> {caught, Exception, Reason}
+    end.
+
+im_impressed() ->
+    try
+        talk(),
+        _Knight = "None shall Pass!",
+        _Doubles = [N*2 || N <- lists:seq(1,100)],
+        throw(up),
+        _WillReturnThis = tequila
+    catch
+        Exception:Reason -> {caught, Exception, Reason}
+    end.
+
+catcher(X,Y) ->
+    case catch X/Y of
+        {'EXIT', {badarith,_}} -> "uh oh";
+        N -> N
+    end.
+
+one_or_two(1) -> return;
+one_or_two(2) -> throw(return).
diff --git a/learn-you-some-erlang/fifo.erl b/learn-you-some-erlang/fifo.erl
new file mode 100644
index 0000000..9687456
--- /dev/null
+++ b/learn-you-some-erlang/fifo.erl
@@ -0,0 +1,15 @@
+-module(fifo).
+-export([new/0, push/2, pop/1, empty/1]).
+
+%% implemented as two stacks; push on the first, pop on the second.
+%% when the second is empty, reverse the first and make it the second.
+new() -> {fifo, [], []}.
+
+push({fifo, In, Out}, X) -> {fifo, [X|In], Out}.
+
+pop({fifo, [], []}) -> erlang:error('empty fifo');
+pop({fifo, In, []}) -> pop({fifo, [], lists:reverse(In)});
+pop({fifo, In, [H|T]}) -> {H, {fifo, In, T}}.
+
+empty({fifo, [], []}) -> true;
+empty({fifo, _, _}) -> false.
diff --git a/learn-you-some-erlang/fifo_types.erl b/learn-you-some-erlang/fifo_types.erl
new file mode 100644
index 0000000..d1bf4ed
--- /dev/null
+++ b/learn-you-some-erlang/fifo_types.erl
@@ -0,0 +1,35 @@
+-module(fifo_types).
+-export([new/0, push/2, pop/1, empty/1]).
+-export([test/0]).
+
+-spec new() -> {fifo, [], []}.
+new() -> {fifo, [], []}.
+
+-spec push({fifo, In::list(), Out::list()}, term()) -> {fifo, list(), list()}.
+push({fifo, In, Out}, X) -> {fifo, [X|In], Out}.
+
+-spec pop({fifo, In::list(), Out::list()}) -> {term(), {fifo, list(), list()}}.
+pop({fifo, [], []}) -> erlang:error('empty fifo');
+pop({fifo, In, []}) -> pop({fifo, [], lists:reverse(In)});
+pop({fifo, In, [H|T]}) -> {H, {fifo, In, T}}.
+
+%-spec empty({fifo, [], []}) -> true;
+%           ({fifo, list(), list()}) -> false.
+%-spec empty({fifo, [], []}) -> true;
+%           ({fifo, [any(), ...], [any(), ...]}) -> false.
+-spec empty({fifo, [], []}) -> true;
+           ({fifo, [any(), ...], []}) -> false;
+           ({fifo, [], [any(), ...]}) -> false;
+           ({fifo, [any(), ...], [any(), ...]}) -> false.
+empty({fifo, [], []}) -> true;
+empty({fifo, _, _}) -> false.
+
+test() ->
+    N = new(),
+    {2, N2} = pop(push(push(new(), 2), 5)),
+    {5, N3} = pop(N2),
+    N = N3,
+    true = empty(N3),
+    false = empty(N2),
+    %pop({fifo, [a|b], [e]}).
+    pop({fifo, [a, b], [e]}).
diff --git a/learn-you-some-erlang/functions.erl b/learn-you-some-erlang/functions.erl
new file mode 100644
index 0000000..730a80d
--- /dev/null
+++ b/learn-you-some-erlang/functions.erl
@@ -0,0 +1,17 @@
+-module(functions).
+-export([head/1, second/1, same/2, valid_time/1]).
+
+head([H|_]) -> H.
+
+second([_,X|_]) -> X.
+
+same(X,X) ->
+    true;
+same(_,_) ->
+    false.
+
+valid_time({Date = {Y,M,D}, Time = {H,Min,S}}) ->
+    io:format("The Date tuple (~p) says today is: ~p/~p/~p,~n",[Date,Y,M,D]),
+    io:format("The time tuple (~p) indicates: ~p:~p:~p.~n", [Time,H,Min,S]);
+valid_time(_) ->
+    io:format("Stop feeding me wrong data!~n").
diff --git a/learn-you-some-erlang/guards.erl b/learn-you-some-erlang/guards.erl
new file mode 100644
index 0000000..3b1a2bc
--- /dev/null
+++ b/learn-you-some-erlang/guards.erl
@@ -0,0 +1,15 @@
+-module(guards).
+-export([old_enough/1, right_age/1, wrong_age/1]).
+
+old_enough(X) when X >= 16 -> true;
+old_enough(_) -> false.
+
+right_age(X) when X >= 16, X =< 104 ->
+    true;
+right_age(_) ->
+    false.
+
+wrong_age(X) when X < 16; X > 104 ->
+    true;
+wrong_age(_) ->
+    false.
diff --git a/learn-you-some-erlang/hhfuns.erl b/learn-you-some-erlang/hhfuns.erl
new file mode 100644
index 0000000..ebe07a4
--- /dev/null
+++ b/learn-you-some-erlang/hhfuns.erl
@@ -0,0 +1,111 @@
+-module(hhfuns).
+-compile(export_all).
+
+one() -> 1.
+two() -> 2.
+
+add(X,Y) -> X() + Y().
+
+increment([]) -> [];
+increment([H|T]) -> [H+1|increment(T)].
+
+decrement([]) -> [];
+decrement([H|T]) -> [H-1|decrement(T)].
+
+
+map(_, []) -> [];
+map(F, [H|T]) -> [F(H)|map(F,T)].
+
+incr(X) -> X + 1.
+decr(X) -> X - 1.
+
+%% bases/1. Refered as the same function refactored in the book
+base1(A) ->
+    B = A + 1,
+    F = fun() -> A * B end,
+    F().
+
+%%% can't compile this one
+%% base(A) ->
+%%    B = A + 1,
+%%    F = fun() -> C = A * B end,
+%%    F(),
+%%    C.
+
+base2() ->
+    A = 1,
+    (fun() -> A = 2 end)().
+
+base3() ->
+    A = 1,
+    (fun(A) -> A = 2 end)(2).
+
+a() ->
+    Secret = "pony",
+    fun() -> Secret end.
+
+b(F) ->
+    "a/0's password is "++F().
+
+even(L) -> lists:reverse(even(L,[])).
+
+even([], Acc) -> Acc;
+even([H|T], Acc) when H rem 2 == 0 ->
+    even(T, [H|Acc]);
+even([_|T], Acc) ->
+    even(T, Acc).
+
+old_men(L) -> lists:reverse(old_men(L,[])).
+
+old_men([], Acc) -> Acc;
+old_men([Person = {male, Age}|People], Acc) when Age > 60 ->
+    old_men(People, [Person|Acc]);
+old_men([_|People], Acc) ->
+    old_men(People, Acc).
+
+filter(Pred, L) -> lists:reverse(filter(Pred, L,[])).
+
+filter(_, [], Acc) -> Acc;
+filter(Pred, [H|T], Acc) ->
+    case Pred(H) of
+        true  -> filter(Pred, T, [H|Acc]);
+        false -> filter(Pred, T, Acc)
+    end.
+
+%% find the maximum of a list
+max([H|T]) -> max2(T, H).
+
+max2([], Max) -> Max;
+max2([H|T], Max) when H > Max -> max2(T, H);
+max2([_|T], Max) -> max2(T, Max).
+
+%% find the minimum of a list
+min([H|T]) -> min2(T,H).
+
+min2([], Min) -> Min;
+min2([H|T], Min) when H < Min -> min2(T,H);
+min2([_|T], Min) -> min2(T, Min).
+
+%% sum of all the elements of a list
+sum(L) -> sum(L,0).
+
+sum([], Sum) -> Sum;
+sum([H|T], Sum) -> sum(T, H+Sum).
+
+fold(_, Start, []) -> Start;
+fold(F, Start, [H|T]) -> fold(F, F(H,Start), T).
+
+reverse(L) ->
+    fold(fun(X,Acc) -> [X|Acc] end, [], L).
+
+map2(F,L) ->
+    reverse(fold(fun(X,Acc) -> [F(X)|Acc] end, [], L)).
+
+filter2(Pred, L) ->
+    F = fun(X,Acc) ->
+            case Pred(X) of
+                true  -> [X|Acc];
+                false -> Acc
+            end
+        end,
+    reverse(fold(F, [], L)).
diff --git a/learn-you-some-erlang/keyval_benchmark.erl b/learn-you-some-erlang/keyval_benchmark.erl
new file mode 100644
index 0000000..45c83be
--- /dev/null
+++ b/learn-you-some-erlang/keyval_benchmark.erl
@@ -0,0 +1,192 @@
+-module(keyval_benchmark).
+-compile(export_all).
+
+%% Runs all benchmarks with Reps number of elements.
+bench(Reps) ->
+    io:format("Base Case:~n"),
+    io:format("Operation\tTotal (µs)\tAverage (µs)~n"),
+    print(base_case(Reps)),
+    io:format("~nNaive Orddict:~n"),
+    io:format("Operation\tTotal (µs)\tAverage (µs)~n"),
+    print(naive_orddict(Reps)),
+    io:format("~nSmart Orddict:~n"),
+    io:format("Operation\tTotal (µs)\tAverage (µs)~n"),
+    print(smart_orddict(Reps)),
+    io:format("~nNaive Dict:~n"),
+    io:format("Operation\tTotal (µs)\tAverage (µs)~n"),
+    print(naive_dict(Reps)),
+    io:format("~nSmart Dict:~n"),
+    io:format("Operation\tTotal (µs)\tAverage (µs)~n"),
+    print(smart_dict(Reps)),
+    io:format("~nNaive gb_trees:~n"),
+    io:format("Operation\tTotal (µs)\tAverage (µs)~n"),
+    print(naive_gb_trees(Reps)),
+    io:format("~nSmart gb_trees:~n"),
+    io:format("Operation\tTotal (µs)\tAverage (µs)~n"),
+    print(smart_gb_trees(Reps)).
+
+%% formats the benchmark results cleanly.
+print([]) -> ok;
+print([{Op, Total, Avg} | Rest]) ->
+    io:format("~8s\t~10B\t~.6f~n", [Op, Total, Avg]),
+    print(Rest).
+
+%% Example of a base benchmark function. This one actually does
+%% nothing and can be used as a control for all the benchmark - it
+%% will measure how much time it takes just to loop over data and
+%% apply functions.
+base_case(Reps) ->
+    benchmark(Reps,                 % N repetitions
+              [],                   % Empty data structure
+              fun ?MODULE:null/3,   % Create
+              fun ?MODULE:null/2,   % Read
+              fun ?MODULE:null/3,   % Update
+              fun ?MODULE:null/2).  % Delete
+
+%% Ordered dictionaries. Assumes that the value is present on reads.
+smart_orddict(Reps) ->
+    benchmark(Reps,
+              orddict:new(),
+              fun orddict:store/3,
+              fun orddict:fetch/2,
+              fun orddict:store/3,
+              fun orddict:erase/2).
+
+%% Ordered dictionaries. Doesn't know whether a key is there or not on
+%% reads.
+naive_orddict(Reps) ->
+    benchmark(Reps,
+              orddict:new(),
+              fun orddict:store/3,
+              fun orddict:find/2,
+              fun orddict:store/3,
+              fun orddict:erase/2).
+
+%% Dictionary benchmark. Assumes that the value is present on reads.
+smart_dict(Reps) ->
+    benchmark(Reps,
+              dict:new(),
+              fun dict:store/3,
+              fun dict:fetch/2,
+              fun dict:store/3,
+              fun dict:erase/2).
+
+%% Dictionary benchmark. Doesn't know if the value exisst at read time.
+naive_dict(Reps) ->
+    benchmark(Reps,
+              dict:new(),
+              fun dict:store/3,
+              fun dict:find/2,
+              fun dict:store/3,
+              fun dict:erase/2).
+
+%% gb_trees benchmark. Uses the most general functions -- i.e.: it never
+%% assumes that the value is not in a tree when inserting and never assumes
+%% it is there when updating or deleting.
+naive_gb_trees(Reps) ->
+    benchmark(Reps,
+              gb_trees:empty(),
+              fun gb_trees:enter/3,
+              fun gb_trees:lookup/2,
+              fun gb_trees:enter/3,
+              fun gb_trees:delete_any/2).
+
+%% gb_trees benchmark. Uses specific function: it assumes that the values
+%% are not there when inserting and assumes it exists when updating or
+%% deleting.
+smart_gb_trees(Reps) ->
+    benchmark(Reps,
+              gb_trees:empty(),
+              fun gb_trees:insert/3,
+              fun gb_trees:get/2,
+              fun gb_trees:update/3,
+              fun gb_trees:delete/2).
+
+%% Empty functions used for the 'base_case/1' benchmark. They must do
+%% nothing interesting.
+null(_, _) -> ok.
+null(_, _, _) -> ok.
+
+%% Runs all the functions of 4 formats: Create, Read, Update, Delete.
+%% Create: it's a regular insertion, but it goes from an empty structure
+%%         to a filled one. Requires an empty data structure,
+%% Read: reads every key from a complete data structure.
+%% Update: usually, this is the same as the insertion from 'create',
+%%         except that it's run on full data structures. In some cases,
+%%         like gb_trees, there also exist operations for updates when
+%%         the keys are known that act differently from regular inserts.
+%% Delete: removes a key from a tree. Because we want to test the
+%%         efficiency of it all, we will always delete from a complete
+%%         structure.
+%% The function returns a list of all times averaged over the number
+%% of repetitions (Reps) needed.
+benchmark(Reps, Empty, CreateFun, ReadFun, UpdateFun, DeleteFun) ->
+    Keys = make_keys(Reps),
+    {TimeC, Struct} = timer:tc(?MODULE, create, [Keys, CreateFun, Empty]),
+    {TimeR, _} = timer:tc(?MODULE, read, [Keys, Struct, ReadFun]),
+    {TimeU, _} = timer:tc(?MODULE, update, [Keys, Struct, UpdateFun]),
+    {TimeD, _} = timer:tc(?MODULE, delete, [Keys, Struct, DeleteFun]),
+    [{create, TimeC, TimeC/Reps},
+     {read, TimeR, TimeR/Reps},
+     {update, TimeU, TimeU/Reps},
+     {delete, TimeD, TimeD/Reps}].
+
+%% Generate unique random numbers. No repetition allowed
+make_keys(N) ->
+    %% The trick is to generate all numbers as usual, but match them
+    %% with a random value in a tuple of the form {Random, Number}.
+    %% The idea is to then sort the list generated that way; done in
+    %% this manner, we know all values will be unique and the randomness
+    %% will be done by the sorting.
+    Random = lists:sort([{random:uniform(N), X} || X <- lists:seq(1, N)]),
+    %% it's a good idea to then filter out the index (the random index)
+    %% to only return the real numbers we want. This is simple to do
+    %% with a list comprehension where '_' removes the extraneous data.
+    %% The keys are then fit into a tuple to make the test a bit more
+    %% realistic for comparison.
+    [{some, key, X} || {_, X} <- Random].
+
+%% Loop function to apply the construction of a data structure.
+%% The parameters passed are a list of all keys to use and then the
+%% higher order function responsible of the creation of a data
+%% structure. This is usually a function of the form
+%% F(Key, Value, Structure).
+%% In the first call, the structure has to be the empty data structure
+%% that will progressively be filled.
+%% The only value inserted for each key is 'some_data'; we only care
+%% about the keys when dealing with key/value stuff.
+create([], _, Acc) -> Acc;
+create([Key|Rest], Fun, Acc) ->
+    create(Rest, Fun, Fun(Key, some_data, Acc)).
+
+%% Loop function to apply successive readings to a data structure.
+%% The parameters passed are a list of all keys, the complete data
+%% structure and then a higher order function responsible for
+%% fetching the data. Such functions are usually of the form
+%% F(Key, Structure).
+read([], _, _) -> ok;
+read([Key|Rest], Struct, Fun) ->
+    Fun(Key, Struct),
+    read(Rest, Struct, Fun).
+
+%% Loop function to apply updates to a data structure.
+%% Takes a list of keys, a full data structure and a higher order
+%% function responsible for the updating, usually of the form
+%% F(Key, NewValue, Structure).
+%% All values for a given key are replaced by 'newval', again because
+%% we don't care about the values, but merely the operations with
+%% the keys.
+update([], _, _) -> ok;
+update([Key|Rest], Struct, Fun) ->
+    Fun(Key, newval, Struct),
+    update(Rest, Struct, Fun).
+
+%% Loop function to apply deletions to a data structure.
+%% Each deletion is made on a full data structure.
+%% Takes a list of keys, a data structure and a higher order function
+%% to do the deletion. Usually of the form
+%% F(Key, Structure).
+delete([], _, _) -> ok;
+delete([Key|Rest], Struct, Fun) ->
+    Fun(Key, Struct),
+    delete(Rest, Struct, Fun).
diff --git a/learn-you-some-erlang/kitchen.erl b/learn-you-some-erlang/kitchen.erl
new file mode 100644
index 0000000..bbe0271
--- /dev/null
+++ b/learn-you-some-erlang/kitchen.erl
@@ -0,0 +1,64 @@
+-module(kitchen).
+-compile(export_all).
+
+start(FoodList) ->
+    spawn(?MODULE, fridge2, [FoodList]).
+
+store(Pid, Food) ->
+    Pid ! {self(), {store, Food}},
+    receive
+        {Pid, Msg} -> Msg
+    end.
+
+take(Pid, Food) ->
+    Pid ! {self(), {take, Food}},
+    receive
+        {Pid, Msg} -> Msg
+    end.
+
+store2(Pid, Food) ->
+    Pid ! {self(), {store, Food}},
+    receive
+        {Pid, Msg} -> Msg
+    after 3000 ->
+        timeout
+    end.
+
+take2(Pid, Food) ->
+    Pid ! {self(), {take, Food}},
+    receive
+        {Pid, Msg} -> Msg
+    after 3000 ->
+        timeout
+    end.
+
+fridge1() ->
+    receive
+        {From, {store, _Food}} ->
+            From ! {self(), ok},
+            fridge1();
+        {From, {take, _Food}} ->
+            %% uh....
+            From ! {self(), not_found},
+            fridge1();
+        terminate ->
+            ok
+    end.
+
+fridge2(FoodList) ->
+    receive
+        {From, {store, Food}} ->
+            From ! {self(), ok},
+            fridge2([Food|FoodList]);
+        {From, {take, Food}} ->
+            case lists:member(Food, FoodList) of
+                true ->
+                    From ! {self(), {ok, Food}},
+                    fridge2(lists:delete(Food, FoodList));
+                false ->
+                    From ! {self(), not_found},
+                    fridge2(FoodList)
+            end;
+        terminate ->
+            ok
+    end.
diff --git a/learn-you-some-erlang/kitty_gen_server.erl b/learn-you-some-erlang/kitty_gen_server.erl
new file mode 100644
index 0000000..c906a6a
--- /dev/null
+++ b/learn-you-some-erlang/kitty_gen_server.erl
@@ -0,0 +1,57 @@
+-module(kitty_gen_server).
+-behaviour(gen_server).
+
+-export([start_link/0, order_cat/4, return_cat/2, close_shop/1]).
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+         terminate/2, code_change/3]).
+
+-record(cat, {name, color=green, description}).
+
+%%% Client API
+start_link() ->
+    gen_server:start_link(?MODULE, [], []).
+
+%% Synchronous call
+order_cat(Pid, Name, Color, Description) ->
+   gen_server:call(Pid, {order, Name, Color, Description}).
+
+%% This call is asynchronous
+return_cat(Pid, Cat = #cat{}) ->
+    gen_server:cast(Pid, {return, Cat}).
+
+%% Synchronous call
+close_shop(Pid) ->
+    gen_server:call(Pid, terminate).
+
+%%% Server functions
+init([]) -> {ok, []}. %% no treatment of info here!
+
+handle_call({order, Name, Color, Description}, _From, Cats) ->
+    if Cats =:= [] ->
+        {reply, make_cat(Name, Color, Description), Cats};
+       Cats =/= [] ->
+        {reply, hd(Cats), tl(Cats)}
+    end;
+handle_call(terminate, _From, Cats) ->
+    {stop, normal, ok, Cats}.
+
+handle_cast({return, Cat = #cat{}}, Cats) ->
+    {noreply, [Cat|Cats]}.
+
+handle_info(Msg, Cats) ->
+    io:format("Unexpected message: ~p~n",[Msg]),
+    {noreply, Cats}.
+
+terminate(normal, Cats) ->
+    [io:format("~p was set free.~n",[C#cat.name]) || C <- Cats],
+    ok.
+
+code_change(_OldVsn, State, _Extra) ->
+    %% No change planned. The function is there for the behaviour,
+    %% but will not be used. Only a version on the next
+    {ok, State}. 
+
+%%% Private functions
+make_cat(Name, Col, Desc) ->
+    #cat{name=Name, color=Col, description=Desc}.
+
diff --git a/learn-you-some-erlang/kitty_server.erl b/learn-you-some-erlang/kitty_server.erl
new file mode 100644
index 0000000..a40e20a
--- /dev/null
+++ b/learn-you-some-erlang/kitty_server.erl
@@ -0,0 +1,74 @@
+%%%%% Naive version
+-module(kitty_server).
+
+-export([start_link/0, order_cat/4, return_cat/2, close_shop/1]).
+
+-record(cat, {name, color=green, description}).
+
+%%% Client API
+start_link() -> spawn_link(fun init/0).
+
+%% Synchronous call
+order_cat(Pid, Name, Color, Description) ->
+    Ref = erlang:monitor(process, Pid),
+    Pid ! {self(), Ref, {order, Name, Color, Description}},
+    receive
+        {Ref, Cat = #cat{}} ->
+            erlang:demonitor(Ref, [flush]),
+            Cat;
+        {'DOWN', Ref, process, Pid, Reason} ->
+            erlang:error(Reason)
+    after 5000 ->
+        erlang:error(timeout)
+    end.
+
+%% This call is asynchronous
+return_cat(Pid, Cat = #cat{}) ->
+    Pid ! {return, Cat},
+    ok.
+
+%% Synchronous call
+close_shop(Pid) ->
+    Ref = erlang:monitor(process, Pid),
+    Pid ! {self(), Ref, terminate},
+    receive
+        {Ref, ok} ->
+            erlang:demonitor(Ref, [flush]),
+            ok;
+        {'DOWN', Ref, process, Pid, Reason} ->
+            erlang:error(Reason)
+    after 5000 ->
+        erlang:error(timeout)
+    end.
+    
+%%% Server functions
+init() -> loop([]).
+
+loop(Cats) ->
+    receive
+        {Pid, Ref, {order, Name, Color, Description}} ->
+            if Cats =:= [] ->
+                Pid ! {Ref, make_cat(Name, Color, Description)},
+                loop(Cats); 
+               Cats =/= [] -> % got to empty the stock
+                Pid ! {Ref, hd(Cats)},
+                loop(tl(Cats))
+            end;
+        {return, Cat = #cat{}} ->
+            loop([Cat|Cats]);
+        {Pid, Ref, terminate} ->
+            Pid ! {Ref, ok},
+            terminate(Cats);
+        Unknown ->
+            %% do some logging here too
+            io:format("Unknown message: ~p~n", [Unknown]),
+            loop(Cats)
+    end.
+
+%%% Private functions
+make_cat(Name, Col, Desc) ->
+    #cat{name=Name, color=Col, description=Desc}.
+
+terminate(Cats) ->
+    [io:format("~p was set free.~n",[C#cat.name]) || C <- Cats],
+    ok.
diff --git a/learn-you-some-erlang/kitty_server2.erl b/learn-you-some-erlang/kitty_server2.erl
new file mode 100644
index 0000000..b2acbb2
--- /dev/null
+++ b/learn-you-some-erlang/kitty_server2.erl
@@ -0,0 +1,49 @@
+%%%%% Abstracted version
+-module(kitty_server2).
+
+-export([start_link/0, order_cat/4, return_cat/2, close_shop/1]).
+-export([init/1, handle_call/3, handle_cast/2]).
+
+-record(cat, {name, color=green, description}).
+
+%%% Client API
+start_link() -> my_server:start_link(?MODULE, []).
+
+%% Synchronous call
+order_cat(Pid, Name, Color, Description) ->
+    my_server:call(Pid, {order, Name, Color, Description}).
+
+%% This call is asynchronous
+return_cat(Pid, Cat = #cat{}) ->
+    my_server:cast(Pid, {return, Cat}).
+
+%% Synchronous call
+close_shop(Pid) ->
+    my_server:call(Pid, terminate).
+
+%%% Server functions
+init([]) -> []. %% no treatment of info here!
+
+handle_call({order, Name, Color, Description}, From, Cats) ->
+    if Cats =:= [] ->
+        my_server:reply(From, make_cat(Name, Color, Description)),
+        Cats;
+       Cats =/= [] ->
+        my_server:reply(From, hd(Cats)),
+        tl(Cats)
+    end;
+
+handle_call(terminate, From, Cats) ->
+    my_server:reply(From, ok),
+    terminate(Cats).
+
+handle_cast({return, Cat = #cat{}}, Cats) ->
+    [Cat|Cats].
+
+%%% Private functions
+make_cat(Name, Col, Desc) ->
+    #cat{name=Name, color=Col, description=Desc}.
+
+terminate(Cats) ->
+    [io:format("~p was set free.~n",[C#cat.name]) || C <- Cats],
+    exit(normal).
diff --git a/learn-you-some-erlang/linkmon.erl b/learn-you-some-erlang/linkmon.erl
new file mode 100644
index 0000000..f93e9e5
--- /dev/null
+++ b/learn-you-some-erlang/linkmon.erl
@@ -0,0 +1,83 @@
+-module(linkmon).
+-compile([export_all]).
+
+myproc() ->
+    timer:sleep(5000),
+    exit(reason).
+
+chain(0) ->
+    receive
+        _ -> ok
+    after 2000 ->
+        exit("chain dies here")
+    end;
+chain(N) ->
+    Pid = spawn(fun() -> chain(N-1) end),
+    link(Pid),
+    receive
+        _ -> ok
+    end.
+
+start_critic() ->
+    spawn(?MODULE, critic, []).
+
+judge(Pid, Band, Album) ->
+    Pid ! {self(), {Band, Album}},
+    receive
+        {Pid, Criticism} -> Criticism
+    after 2000 ->
+        timeout
+    end.
+
+critic() ->
+    receive
+        {From, {"Rage Against the Turing Machine", "Unit Testify"}} ->
+            From ! {self(), "They are great!"};
+        {From, {"System of a Downtime", "Memoize"}} ->
+            From ! {self(), "They're not Johnny Crash but they're good."};
+        {From, {"Johnny Crash", "The Token Ring of Fire"}} ->
+            From ! {self(), "Simply incredible."};
+        {From, {_Band, _Album}} ->
+            From ! {self(), "They are terrible!"}
+    end,
+    critic().
+
+
+start_critic2() ->
+    spawn(?MODULE, restarter, []).
+
+restarter() ->
+    process_flag(trap_exit, true),
+    Pid = spawn_link(?MODULE, critic2, []),
+    register(critic, Pid),
+    receive
+        {'EXIT', Pid, normal} -> % not a crash
+            ok;
+        {'EXIT', Pid, shutdown} -> % manual shutdown, not a crash
+            ok;
+        {'EXIT', Pid, _} ->
+            restarter()
+    end.
+
+judge2(Band, Album) ->
+    Ref = make_ref(),
+    critic ! {self(), Ref, {Band, Album}},
+    receive
+        {Ref, Criticism} -> Criticism
+    after 2000 ->
+        timeout
+    end.
+
+critic2() ->
+    receive
+        {From, Ref, {"Rage Against the Turing Machine", "Unit Testify"}} ->
+            From ! {Ref, "They are great!"};
+        {From, Ref, {"System of a Downtime", "Memoize"}} ->
+            From ! {Ref, "They're not Johnny Crash but they're good."};
+        {From, Ref, {"Johnny Crash", "The Token Ring of Fire"}} ->
+            From ! {Ref, "Simply incredible."};
+        {From, Ref, {_Band, _Album}} ->
+            From ! {Ref, "They are terrible!"}
+    end,
+    critic2().
+
diff --git a/learn-you-some-erlang/m8ball/Emakefile b/learn-you-some-erlang/m8ball/Emakefile
new file mode 100644
index 0000000..b203ea3
--- /dev/null
+++ b/learn-you-some-erlang/m8ball/Emakefile
@@ -0,0 +1,2 @@
+{["src/*", "test/*"],
+ [{i,"include"}, {outdir, "ebin"}]}.
diff --git a/learn-you-some-erlang/m8ball/config/a.config b/learn-you-some-erlang/m8ball/config/a.config
new file mode 100644
index 0000000..983d5e1
--- /dev/null
+++ b/learn-you-some-erlang/m8ball/config/a.config
@@ -0,0 +1,9 @@
+[{kernel,
+  [{distributed, [{m8ball,
+                   5000,
+                  [a@ferdmbp, {b@ferdmbp, c@ferdmbp}]}]},
+   {sync_nodes_mandatory, [b@ferdmbp, c@ferdmbp]},
+   {sync_nodes_timeout, 30000}
+  ]
+ }
+].
diff --git a/learn-you-some-erlang/m8ball/config/b.config b/learn-you-some-erlang/m8ball/config/b.config
new file mode 100644
index 0000000..2d0ccfc
--- /dev/null
+++ b/learn-you-some-erlang/m8ball/config/b.config
@@ -0,0 +1,9 @@
+[{kernel,
+  [{distributed, [{m8ball,
+                   5000,
+                  [a@ferdmbp, {b@ferdmbp, c@ferdmbp}]}]},
+   {sync_nodes_mandatory, [a@ferdmbp, c@ferdmbp]},
+   {sync_nodes_timeout, 30000}
+  ]
+ }
+].
diff --git a/learn-you-some-erlang/m8ball/config/c.config b/learn-you-some-erlang/m8ball/config/c.config
new file mode 100644
index 0000000..3dd3609
--- /dev/null
+++ b/learn-you-some-erlang/m8ball/config/c.config
@@ -0,0 +1,9 @@
+[{kernel,
+  [{distributed, [{m8ball,
+                   5000,
+                  [a@ferdmbp, {b@ferdmbp, c@ferdmbp}]}]},
+   {sync_nodes_mandatory, [a@ferdmbp, b@ferdmbp]},
+   {sync_nodes_timeout, 30000}
+  ]
+ }
+].
diff --git a/learn-you-some-erlang/m8ball/ebin/m8ball.app b/learn-you-some-erlang/m8ball/ebin/m8ball.app
new file mode 100644
index 0000000..352c1d4
--- /dev/null
+++ b/learn-you-some-erlang/m8ball/ebin/m8ball.app
@@ -0,0 +1,13 @@
+{application, m8ball,
+ [{vsn, "1.0.0"},
+  {description, "Answer vital questions"},
+  {modules, [m8ball, m8ball_sup, m8ball_server]},
+  {applications, [stdlib, kernel, crypto]},
+  {registered, [m8ball, m8ball_sup, m8ball_server]},
+  {mod, {m8ball, []}},
+  {env, [
+    {answers, {<<"Yes">>, <<"No">>, <<"Doubtful">>,
+               <<"I don't like your tone">>, <<"Of course">>,
+               <<"Of course not">>, <<"*backs away slowly and runs away*">>}}
+  ]}
+ ]}.
diff --git a/learn-you-some-erlang/m8ball/logs/.track-this b/learn-you-some-erlang/m8ball/logs/.track-this
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/learn-you-some-erlang/m8ball/logs/.track-this
diff --git a/learn-you-some-erlang/m8ball/src/m8ball.erl b/learn-you-some-erlang/m8ball/src/m8ball.erl
new file mode 100644
index 0000000..041601b
--- /dev/null
+++ b/learn-you-some-erlang/m8ball/src/m8ball.erl
@@ -0,0 +1,24 @@
+-module(m8ball).
+-behaviour(application).
+-export([start/2, stop/1]).
+-export([ask/1]).
+
+%%%%%%%%%%%%%%%%%
+%%% CALLBACKS %%%
+%%%%%%%%%%%%%%%%%
+
+%% start({failover, Node}, Args) is only called
+%% when a start_phase key is defined.
+start(normal, []) ->
+    m8ball_sup:start_link();
+start({takeover, _OtherNode}, []) ->
+    m8ball_sup:start_link().
+
+stop(_State) ->
+    ok.
+
+%%%%%%%%%%%%%%%%%
+%%% INTERFACE %%%
+%%%%%%%%%%%%%%%%%
+ask(Question) ->
+    m8ball_server:ask(Question).
diff --git a/learn-you-some-erlang/m8ball/src/m8ball_server.erl b/learn-you-some-erlang/m8ball/src/m8ball_server.erl
new file mode 100644
index 0000000..4e821ad
--- /dev/null
+++ b/learn-you-some-erlang/m8ball/src/m8ball_server.erl
@@ -0,0 +1,46 @@
+-module(m8ball_server).
+-behaviour(gen_server).
+-export([start_link/0, stop/0, ask/1]).
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+         code_change/3, terminate/2]).
+
+%%%%%%%%%%%%%%%%%
+%%% INTERFACE %%%
+%%%%%%%%%%%%%%%%%
+start_link() ->
+    gen_server:start_link({global, ?MODULE}, ?MODULE, [], []).
+
+stop() ->
+    gen_server:call({global, ?MODULE}, stop).
+
+ask(_Question) -> % the question doesn't matter!
+    gen_server:call({global, ?MODULE}, question).
+
+%%%%%%%%%%%%%%%%%
+%%% CALLBACKS %%%
+%%%%%%%%%%%%%%%%%
+init([]) ->
+    <<A:32, B:32, C:32>> = crypto:rand_bytes(12),
+    random:seed(A,B,C),
+    {ok, []}.
+
+handle_call(question, _From, State) ->
+    {ok, Answers} = application:get_env(m8ball, answers),
+    Answer = element(random:uniform(tuple_size(Answers)), Answers),
+    {reply, Answer, State};
+handle_call(stop, _From, State) ->
+    {stop, normal, ok, State};
+handle_call(_Call, _From, State) ->
+    {noreply, State}.
+
+handle_cast(_Cast, State) ->
+    {noreply, State}.
+
+handle_info(_Info, State) ->
+    {noreply, State}.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+terminate(_Reason, _State) ->
+    ok.
diff --git a/learn-you-some-erlang/m8ball/src/m8ball_sup.erl b/learn-you-some-erlang/m8ball/src/m8ball_sup.erl
new file mode 100644
index 0000000..ca5e426
--- /dev/null
+++ b/learn-you-some-erlang/m8ball/src/m8ball_sup.erl
@@ -0,0 +1,16 @@
+-module(m8ball_sup).
+-behaviour(supervisor).
+-export([start_link/0, init/1]).
+
+start_link() ->
+    supervisor:start_link({global,?MODULE}, ?MODULE, []).
+
+init([]) ->
+    {ok, {{one_for_one, 1, 10},
+          [{m8ball,
+            {m8ball_server, start_link, []},
+            permanent,
+            5000,
+            worker,
+            [m8ball_server]
+          }]}}.
diff --git a/learn-you-some-erlang/m8ball/test/dist_m8ball_SUITE.erl b/learn-you-some-erlang/m8ball/test/dist_m8ball_SUITE.erl
new file mode 100644
index 0000000..3afba6e
--- /dev/null
+++ b/learn-you-some-erlang/m8ball/test/dist_m8ball_SUITE.erl
@@ -0,0 +1,32 @@
+-module(dist_m8ball_SUITE).
+-include_lib("common_test/include/ct.hrl").
+-export([all/0, groups/0, init_per_group/2, end_per_group/2]).
+-export([can_contact/1]).
+
+all() -> [{group, main}, {group, backup}].
+
+groups() -> [{main,
+             [],
+             [can_contact]},
+            {backup,
+             [],
+             [can_contact]}].
+
+init_per_group(main, Config) ->
+    application:start(crypto),
+    application:start(m8ball),
+    Config;
+init_per_group(backup, Config) ->
+    application:start(crypto),
+    application:start(m8ball),
+    Config.
+
+end_per_group(main, _Config) ->
+    %application:stop(m8ball),
+    ok;
+end_per_group(backup, _Config) ->
+    %application:stop(m8ball),
+    ok.
+
+can_contact(_Config) ->
+    <<_/binary>> = m8ball:ask(<<"Some Question">>).
diff --git a/learn-you-some-erlang/m8ball/test/dist_m8ball_SUITE_data/backup.config b/learn-you-some-erlang/m8ball/test/dist_m8ball_SUITE_data/backup.config
new file mode 100644
index 0000000..7fbe260
--- /dev/null
+++ b/learn-you-some-erlang/m8ball/test/dist_m8ball_SUITE_data/backup.config
@@ -0,0 +1,9 @@
+[{kernel,
+  [{distributed, [{m8ball,
+                   5000,
+                  ['a@li101-172.members.linode.com', 'b@li101-172.members.linode.com']}]},
+   {sync_nodes_mandatory, ['a@li101-172.members.linode.com']},
+   {sync_nodes_timeout, 5000}
+  ]
+ }
+].
diff --git a/learn-you-some-erlang/m8ball/test/dist_m8ball_SUITE_data/main.config b/learn-you-some-erlang/m8ball/test/dist_m8ball_SUITE_data/main.config
new file mode 100644
index 0000000..bcac447
--- /dev/null
+++ b/learn-you-some-erlang/m8ball/test/dist_m8ball_SUITE_data/main.config
@@ -0,0 +1,9 @@
+[{kernel,
+  [{distributed, [{m8ball,
+                   5000,
+                  ['a@li101-172.members.linode.com', 'b@li101-172.members.linode.com']}]},
+   {sync_nodes_mandatory, ['b@li101-172.members.linode.com']},
+   {sync_nodes_timeout, 5000}
+  ]
+ }
+].
diff --git a/learn-you-some-erlang/m8ball/test/m8ball.spec b/learn-you-some-erlang/m8ball/test/m8ball.spec
new file mode 100644
index 0000000..51d9cf3
--- /dev/null
+++ b/learn-you-some-erlang/m8ball/test/m8ball.spec
@@ -0,0 +1,5 @@
+{include, "../include/"}.
+{alias, root, "/home/ferd/code/learn-you-some-erlang/m8ball/test"}.
+{logdir, "/home/ferd/code/learn-you-some-erlang/m8ball/logs"}.
+
+{suites, root, all}.
diff --git a/learn-you-some-erlang/m8ball/test/m8ball_dist.spec b/learn-you-some-erlang/m8ball/test/m8ball_dist.spec
new file mode 100644
index 0000000..c49a6ca
--- /dev/null
+++ b/learn-you-some-erlang/m8ball/test/m8ball_dist.spec
@@ -0,0 +1,20 @@
+{node, master, 'ct@li101-172.members.linode.com'}.
+{node, a, 'a@li101-172.members.linode.com'}.
+{node, b, 'b@li101-172.members.linode.com'}.
+
+{init, a, [{node_start, [{monitor_master, true},
+                         {boot_timeout, 10000},
+                         {erl_flags, "-pa /home/ferd/code/learn-you-some-erlang/m8ball/ebin/ "
+                                     "-config /home/ferd/code/learn-you-some-erlang/m8ball/test/dist_m8ball_SUITE_data/main.config"}]}]}.
+{init, b, [{node_start, [{monitor_master, true},
+                         {boot_timeout, 10000},
+                         {erl_flags, "-pa /home/ferd/code/learn-you-some-erlang/m8ball/ebin/ "
+                                     "-config /home/ferd/code/learn-you-some-erlang/m8ball/test/dist_m8ball_SUITE_data/backup.config"}]}]}.
+
+{include, "../include/"}.
+{alias, root, "/home/ferd/code/learn-you-some-erlang/m8ball/test"}.
+{logdir, "/home/ferd/code/learn-you-some-erlang/m8ball/logs"}.
+{logdir, master, "/home/ferd/code/learn-you-some-erlang/m8ball/logs"}.
+
+{groups, a, root, dist_m8ball_SUITE, main}.
+{groups, b, root, dist_m8ball_SUITE, backup}.
diff --git a/learn-you-some-erlang/m8ball/test/m8ball_server_SUITE.erl b/learn-you-some-erlang/m8ball/test/m8ball_server_SUITE.erl
new file mode 100644
index 0000000..6bc4156
--- /dev/null
+++ b/learn-you-some-erlang/m8ball/test/m8ball_server_SUITE.erl
@@ -0,0 +1,45 @@
+-module(m8ball_server_SUITE).
+-include_lib("common_test/include/ct.hrl").
+-export([all/0, init_per_testcase/2, end_per_testcase/2]).
+-export([random_answer/1, binary_answer/1, determined_answers/1,
+         reload_answers/1]).
+
+all() -> [random_answer, binary_answer, determined_answers,
+          reload_answers].
+
+init_per_testcase(_Test, Config) ->
+    Answers = [<<"Outlook not so good">>,
+               <<"I don't think so">>,
+               <<"Yes, definitely">>,
+               <<"STOP SHAKING ME">>],
+    application:set_env(m8ball, answers, list_to_tuple(Answers)),
+    m8ball_server:start_link(),
+    [{answers, Answers} | Config].
+
+end_per_testcase(_Test, _Config) ->
+    m8ball_server:stop().
+
+%% The answer should come from the config
+random_answer(_Config) ->
+    Answers1 = [m8ball_server:ask("Dummy question") || _ <- lists:seq(1,15)],
+    Answers2 = [m8ball_server:ask("Dummy question") || _ <- lists:seq(1,15)],
+    true = 1 < length(sets:to_list(sets:from_list(Answers1))),
+    true = Answers1 =/= Answers2.
+
+binary_answer(_Config) ->
+    Answers = [m8ball_server:ask("Dummy question") || _ <- lists:seq(1,15)],
+    L = length(Answers),
+    L = length(lists:filter(fun erlang:is_binary/1, Answers)).
+
+determined_answers(Config) ->
+    Answers = ?config(answers, Config),
+    Res = [m8ball_server:ask("Dummy question") || _ <- lists:seq(1,15)],
+    true = lists:all(fun(X) -> lists:member(X, Answers) end, Res).
+
+reload_answers(_Config) ->
+    Ref = make_ref(),
+    application:set_env(m8ball, answers, {Ref}),
+    [Ref,Ref,Ref] = [m8ball_server:ask("Question") || _ <- lists:seq(1,3)].
+    
+
+%% NOTE: do distributed testing in m8ball_SUITE or something
diff --git a/learn-you-some-erlang/mafiapp-1.0.0/Emakefile b/learn-you-some-erlang/mafiapp-1.0.0/Emakefile
new file mode 100644
index 0000000..b203ea3
--- /dev/null
+++ b/learn-you-some-erlang/mafiapp-1.0.0/Emakefile
@@ -0,0 +1,2 @@
+{["src/*", "test/*"],
+ [{i,"include"}, {outdir, "ebin"}]}.
diff --git a/learn-you-some-erlang/mafiapp-1.0.0/ebin/mafiapp.app b/learn-you-some-erlang/mafiapp-1.0.0/ebin/mafiapp.app
new file mode 100644
index 0000000..972432f
--- /dev/null
+++ b/learn-you-some-erlang/mafiapp-1.0.0/ebin/mafiapp.app
@@ -0,0 +1,5 @@
+{application, mafiapp,
+ [{description, "Help the boss keep track of his friends"},
+  {vsn, "1.0.0"},
+  {modules, [mafiapp, mafiapp_sup]},
+  {applications, [stdlib, kernel, mnesia]}]}.
diff --git a/learn-you-some-erlang/mafiapp-1.0.0/logs/.keep-this b/learn-you-some-erlang/mafiapp-1.0.0/logs/.keep-this
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/learn-you-some-erlang/mafiapp-1.0.0/logs/.keep-this
diff --git a/learn-you-some-erlang/mafiapp-1.0.0/mafiapp.spec b/learn-you-some-erlang/mafiapp-1.0.0/mafiapp.spec
new file mode 100644
index 0000000..4953e67
--- /dev/null
+++ b/learn-you-some-erlang/mafiapp-1.0.0/mafiapp.spec
@@ -0,0 +1,3 @@
+{alias, root, "./test/"}.
+{logdir, "./logs/"}.
+{suites, root, all}.
diff --git a/learn-you-some-erlang/mafiapp-1.0.0/src/mafiapp.erl b/learn-you-some-erlang/mafiapp-1.0.0/src/mafiapp.erl
new file mode 100644
index 0000000..0e6a2b0
--- /dev/null
+++ b/learn-you-some-erlang/mafiapp-1.0.0/src/mafiapp.erl
@@ -0,0 +1,172 @@
+-module(mafiapp).
+-behaviour(application).
+-include_lib("stdlib/include/ms_transform.hrl").
+-export([start/2, stop/1]).
+-export([install/1]).
+-export([add_friend/4, friend_by_name/1, friend_by_expertise/1,
+         add_service/4, debts/1]).
+-export([add_enemy/2, find_enemy/1, enemy_killed/1]).
+
+
+-record(mafiapp_friends, {name,
+                          contact=[],
+                          info=[],
+                          expertise}).
+-record(mafiapp_services, {from,
+                           to,
+                           date,
+                           description}).
+-record(mafiapp_enemies, {name,
+                          info=[]}).
+
+start(normal, []) ->
+    mnesia:wait_for_tables([mafiapp_friends,
+                            mafiapp_services,
+                            mafiapp_enemies], 5000),
+    mafiapp_sup:start_link().
+
+
+stop(_) -> ok.
+
+install(Nodes) ->
+    ok = mnesia:create_schema(Nodes),
+    rpc:multicall(Nodes, application, start, [mnesia]),
+    mnesia:create_table(mafiapp_friends,
+                        [{attributes, record_info(fields, mafiapp_friends)},
+                         {index, [#mafiapp_friends.expertise]},
+                         {disc_copies, Nodes}]),
+    mnesia:create_table(mafiapp_services,
+                        [{attributes, record_info(fields, mafiapp_services)},
+                         {index, [#mafiapp_services.to]},
+                         {disc_copies, Nodes},
+                         {type, bag}]),
+    mnesia:create_table(mafiapp_enemies,
+                        [{attributes, record_info(fields, mafiapp_enemies)},
+                         {disc_copies, Nodes},
+                         {local_content, true}]),
+    rpc:multicall(Nodes, application, stop, [mnesia]).
+
+add_friend(Name, Contact, Info, Expertise) ->
+    F = fun() ->
+        mnesia:write(#mafiapp_friends{name=Name,
+                                      contact=Contact,
+                                      info=Info,
+                                      expertise=Expertise})
+    end,
+    mnesia:activity(transaction, F).
+
+friend_by_name(Name) ->
+    F = fun() ->
+        case mnesia:read({mafiapp_friends, Name}) of
+            [#mafiapp_friends{contact=C, info=I, expertise=E}] ->
+                {Name,C,I,E,find_services(Name)};
+            [] ->
+                undefined
+        end
+    end,
+    mnesia:activity(transaction, F).
+
+friend_by_expertise(Expertise) ->
+    %% Alternative form:
+    %% MatchSpec = [{#mafiapp_friends{name = '$1',
+    %%                                contact = '$2',
+    %%                                info = '$3',
+    %%                                expertise = Expertise},
+    %%               [],
+    %%               [{{'$1','$2','$3',Expertise}}]}],
+    %% F = fun() ->
+    %%     [{Name,C,I,E,find_services(Name)} ||
+    %%         {Name,C,I,E} <- mnesia:select(mafiapp_friends, MatchSpec)]
+    %% end,
+    Pattern = #mafiapp_friends{_ = '_',
+                               expertise = Expertise},
+    F = fun() ->
+            Res = mnesia:match_object(Pattern),
+            [{Name,C,I,Expertise,find_services(Name)} ||
+                #mafiapp_friends{name=Name,
+                                 contact=C,
+                                 info=I} <- Res]
+    end,
+    mnesia:activity(transaction, F).
+
+%% Adding validation is left to the reader
+add_service(From, To, Date, Description) ->
+    F = fun() ->
+            case mnesia:read({mafiapp_friends, From}) =:= [] orelse
+                 mnesia:read({mafiapp_friends, To}) =:= [] of
+                true ->
+                    {error, unknown_friend};
+                false ->
+                    mnesia:write(#mafiapp_services{from=From,
+                                                   to=To,
+                                                   date=Date,
+                                                   description=Description})
+            end
+    end,
+    mnesia:activity(transaction,F).
+
+debts(Name) ->
+    Match = ets:fun2ms(
+            fun(#mafiapp_services{from=From, to=To}) when From =:= Name ->
+                {To,-1};
+                (#mafiapp_services{from=From, to=To}) when To =:= Name ->
+                {From,1}
+            end),
+    F = fun() -> mnesia:select(mafiapp_services, Match) end,
+    Dict = lists:foldl(fun({Person,N}, Dict) ->
+                        dict:update(Person, fun(X) -> X + N end, N, Dict)
+                       end,
+                       dict:new(),
+                       mnesia:activity(transaction, F)),
+    lists:sort([{V,K} || {K,V} <- dict:to_list(Dict)]).
+%% The following implementation is a somewhat more efficient
+%% alternative on large databases, given it will use indexes
+%% rather than traversing the entire table.
+%    F = fun() ->
+%            Given = mnesia:read({mafiapp_services, Name}),
+%            Received = mnesia:match_object(#mafiapp_services{to=Name, _='_'}),
+%            {Given, Received}
+%    end,
+%    {Given, Received} = mnesia:activity(transaction, F),
+%    Dict1 = lists:foldl(fun(#mafiapp_services{to=N}, Dict) ->
+%                            dict:update(N, fun(X) -> X - 1 end, -1, Dict)
+%                        end,
+%                        dict:new(),
+%                        Given),
+%    Dict2 = lists:foldl(fun(#mafiapp_services{from=N}, Dict) ->
+%                            dict:update(N, fun(X) -> X + 1 end, 1, Dict)
+%                        end,
+%                        Dict1,
+%                        Received),
+%    lists:sort([{V,K} || {K,V} <- dict:to_list(Dict2)]).
+
+add_enemy(Name, Info) ->
+    F = fun() -> mnesia:write(#mafiapp_enemies{name=Name, info=Info}) end,
+    mnesia:activity(transaction, F).
+
+find_enemy(Name) ->
+    F = fun() -> mnesia:read({mafiapp_enemies, Name}) end,
+    case mnesia:activity(transaction, F) of
+        [] -> undefined;
+        [#mafiapp_enemies{name=N, info=I}] -> {N,I}
+    end.
+
+enemy_killed(Name) ->
+    F = fun() -> mnesia:delete({mafiapp_enemies, Name}) end,
+    mnesia:activity(transaction, F).
+
+%%%%%%%%%%%%%%%
+%%% PRIVATE %%%
+%%%%%%%%%%%%%%%
+
+find_services(Name) ->
+    Match = ets:fun2ms(
+            fun(#mafiapp_services{from=From, to=To, date=D, description=Desc})
+                when From =:= Name ->
+                    {to, To, D, Desc};
+               (#mafiapp_services{from=From, to=To, date=D, description=Desc})
+                when To =:= Name ->
+                    {from, From, D, Desc}
+            end
+    ),
+    mnesia:select(mafiapp_services, Match).
diff --git a/learn-you-some-erlang/mafiapp-1.0.0/src/mafiapp_sup.erl b/learn-you-some-erlang/mafiapp-1.0.0/src/mafiapp_sup.erl
new file mode 100644
index 0000000..e31b221
--- /dev/null
+++ b/learn-you-some-erlang/mafiapp-1.0.0/src/mafiapp_sup.erl
@@ -0,0 +1,12 @@
+-module(mafiapp_sup).
+-behaviour(supervisor).
+-export([start_link/0]).
+-export([init/1]).
+
+start_link() ->
+    supervisor:start_link(?MODULE, []).
+
+%% This does absolutely nothing, only there to
+%% allow to wait for tables.
+init([]) ->
+    {ok, {{one_for_one, 1, 1}, []}}.
diff --git a/learn-you-some-erlang/mafiapp-1.0.0/test/mafiapp.spec b/learn-you-some-erlang/mafiapp-1.0.0/test/mafiapp.spec
new file mode 100644
index 0000000..4953e67
--- /dev/null
+++ b/learn-you-some-erlang/mafiapp-1.0.0/test/mafiapp.spec
@@ -0,0 +1,3 @@
+{alias, root, "./test/"}.
+{logdir, "./logs/"}.
+{suites, root, all}.
diff --git a/learn-you-some-erlang/mafiapp-1.0.0/test/mafiapp_SUITE.erl b/learn-you-some-erlang/mafiapp-1.0.0/test/mafiapp_SUITE.erl
new file mode 100644
index 0000000..6005d29
--- /dev/null
+++ b/learn-you-some-erlang/mafiapp-1.0.0/test/mafiapp_SUITE.erl
@@ -0,0 +1,128 @@
+-module(mafiapp_SUITE).
+-include_lib("common_test/include/ct.hrl").
+-export([init_per_suite/1, end_per_suite/1,
+         init_per_testcase/2, end_per_testcase/2,
+         all/0]).
+-export([add_service/1, friend_by_name/1, friend_by_expertise/1,
+         friend_with_services/1, accounts/1, enemies/1]).
+
+all() -> [add_service, friend_by_name, friend_by_expertise,
+          friend_with_services, accounts, enemies].
+
+init_per_suite(Config) ->
+    Priv = ?config(priv_dir, Config),
+    application:load(mnesia),
+    application:set_env(mnesia, dir, Priv),
+    application:load(mafiapp),
+    mafiapp:install([node()]),
+    application:start(mnesia),
+    application:start(mafiapp),
+    Config.
+
+end_per_suite(_Config) ->
+    application:stop(mnesia),
+    ok.
+
+init_per_testcase(add_service, Config) ->
+    Config;
+init_per_testcase(accounts, Config) ->
+    ok = mafiapp:add_friend("Consigliere", [], [you], consigliere),
+    Config;
+init_per_testcase(_, Config) ->
+    ok = mafiapp:add_friend("Don Corleone", [], [boss], boss),
+    Config.
+
+end_per_testcase(_, _Config) ->
+    ok.
+
+%% services can go both way: from a friend to the boss, or
+%% from the boss to a friend! A boss friend is required!
+add_service(_Config) ->
+    {error, unknown_friend} = mafiapp:add_service("from name",
+                                                  "to name",
+                                                  {1946,5,23},
+                                                  "a fake service"),
+    ok = mafiapp:add_friend("Don Corleone", [], [boss], boss),
+    ok = mafiapp:add_friend("Alan Parsons",
+                            [{twitter,"@ArtScienceSound"}],
+                            [{born, {1948,12,20}},
+                             musician, 'audio engineer',
+                             producer, "has projects"],
+                            mixing),
+    ok = mafiapp:add_service("Alan Parsons", "Don Corleone",
+                             {1973,3,1},
+                             "Helped release a Pink Floyd album").
+
+friend_by_name(_Config) ->
+    ok = mafiapp:add_friend("Pete Cityshend",
+                            [{phone, "418-542-3000"},
+                             {email, "quadrophonia@example.org"},
+                             {other, "yell real loud"}],
+                            [{born, {1945,5,19}},
+                             musician, popular],
+                            music),
+    {"Pete Cityshend",
+     _Contact, _Info, music,
+     _Services} = mafiapp:friend_by_name("Pete Cityshend"),
+    undefined = mafiapp:friend_by_name(make_ref()).
+
+friend_by_expertise(_Config) ->
+    ok = mafiapp:add_friend("A Red Panda",
+                            [{location, "in a zoo"}],
+                            [animal,cute],
+                            climbing),
+    [{"A Red Panda",
+      _Contact, _Info, climbing,
+     _Services}] = mafiapp:friend_by_expertise(climbing),
+    [] = mafiapp:friend_by_expertise(make_ref()).
+
+friend_with_services(_Config) ->
+    ok = mafiapp:add_friend("Someone", [{other, "at the fruit stand"}],
+                            [weird, mysterious], shadiness),
+    ok = mafiapp:add_service("Don Corleone", "Someone",
+                             {1949,2,14}, "Increased business"),
+    ok = mafiapp:add_service("Someone", "Don Corleone",
+                             {1949,12,25}, "Gave a Christmas gift"),
+    %% We don't care about the order. The test was made to fit
+    %% whatever the functions returned.
+    {"Someone",
+     _Contact, _Info, shadiness,
+     [{to, "Don Corleone", {1949,12,25}, "Gave a Christmas gift"},
+      {from, "Don Corleone", {1949,2,14}, "Increased business"}]} =
+    mafiapp:friend_by_name("Someone").
+
+%% It should be possible to find all people who owe us things.
+accounts(_Config) ->
+    ok = mafiapp:add_friend("Gill Bates", [{email, "ceo@macrohard.com"}],
+                            [clever,rich], computers),
+    ok = mafiapp:add_service("Consigliere", "Gill Bates",
+                             {1985,11,20}, "Bought 15 copies of software"),
+    ok = mafiapp:add_service("Gill Bates", "Consigliere",
+                             {1986,8,17}, "Made computer faster"),
+    ok = mafiapp:add_friend("Pierre Gauthier", [{other, "city arena"}],
+                            [{job, "sports team GM"}], sports),
+    ok = mafiapp:add_service("Pierre Gauthier", "Consigliere", {2009,6,30},
+                             "Took on a huge, bad contract"),
+    ok = mafiapp:add_friend("Wayne Gretzky", [{other, "Canada"}],
+                            [{born, {1961,1,26}}, "hockey legend"],
+                            hockey),
+    ok = mafiapp:add_service("Consigliere", "Wayne Gretzky", {1964,1,26},
+                             "Gave first pair of ice skates"),
+    %% Wayne Gretzky owes us something so the debt is negative
+    %% Gill Bates are equal
+    %% Gauthier is owed a service.
+    [{-1,"Wayne Gretzky"},
+     {0,"Gill Bates"},
+     {1,"Pierre Gauthier"}] = mafiapp:debts("Consigliere"),
+    [{1, "Consigliere"}] = mafiapp:debts("Wayne Gretzky").
+
+enemies(_Config) ->
+    undefined = mafiapp:find_enemy("Edward"),
+    ok = mafiapp:add_enemy("Edward", [{bio, "Vampire"},
+                                  {comment, "He sucks (blood)"}]),
+    {"Edward", [{bio, "Vampire"},
+                {comment, "He sucks (blood)"}]} =
+       mafiapp:find_enemy("Edward"),
+    ok = mafiapp:enemy_killed("Edward"),
+    undefined = mafiapp:find_enemy("Edward").
+
diff --git a/learn-you-some-erlang/mafiapp-1.0.1/Emakefile b/learn-you-some-erlang/mafiapp-1.0.1/Emakefile
new file mode 100644
index 0000000..b203ea3
--- /dev/null
+++ b/learn-you-some-erlang/mafiapp-1.0.1/Emakefile
@@ -0,0 +1,2 @@
+{["src/*", "test/*"],
+ [{i,"include"}, {outdir, "ebin"}]}.
diff --git a/learn-you-some-erlang/mafiapp-1.0.1/ebin/mafiapp.app b/learn-you-some-erlang/mafiapp-1.0.1/ebin/mafiapp.app
new file mode 100644
index 0000000..f4268ae
--- /dev/null
+++ b/learn-you-some-erlang/mafiapp-1.0.1/ebin/mafiapp.app
@@ -0,0 +1,5 @@
+{application, mafiapp,
+ [{description, "Help the boss keep track of his friends"},
+  {vsn, "1.0.1"},
+  {modules, [mafiapp, mafiapp_sup]},
+  {applications, [stdlib, kernel, mnesia]}]}.
diff --git a/learn-you-some-erlang/mafiapp-1.0.1/logs/.please-track-this b/learn-you-some-erlang/mafiapp-1.0.1/logs/.please-track-this
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/learn-you-some-erlang/mafiapp-1.0.1/logs/.please-track-this
diff --git a/learn-you-some-erlang/mafiapp-1.0.1/mafiapp.spec b/learn-you-some-erlang/mafiapp-1.0.1/mafiapp.spec
new file mode 100644
index 0000000..4953e67
--- /dev/null
+++ b/learn-you-some-erlang/mafiapp-1.0.1/mafiapp.spec
@@ -0,0 +1,3 @@
+{alias, root, "./test/"}.
+{logdir, "./logs/"}.
+{suites, root, all}.
diff --git a/learn-you-some-erlang/mafiapp-1.0.1/src/mafiapp.erl b/learn-you-some-erlang/mafiapp-1.0.1/src/mafiapp.erl
new file mode 100644
index 0000000..f40ebce
--- /dev/null
+++ b/learn-you-some-erlang/mafiapp-1.0.1/src/mafiapp.erl
@@ -0,0 +1,142 @@
+-module(mafiapp).
+-behaviour(application).
+-include_lib("stdlib/include/ms_transform.hrl").
+-include_lib("stdlib/include/qlc.hrl").
+-export([start/2, stop/1]).
+-export([install/1]).
+-export([add_friend/4, friend_by_name/1, friend_by_expertise/1,
+         add_service/4, debts/1]).
+-export([add_enemy/2, find_enemy/1, enemy_killed/1]).
+
+
+-record(mafiapp_friends, {name,
+                          contact=[],
+                          info=[],
+                          expertise}).
+-record(mafiapp_services, {from,
+                           to,
+                           date,
+                           description}).
+-record(mafiapp_enemies, {name,
+                          info=[]}).
+
+start(normal, []) ->
+    mnesia:wait_for_tables([mafiapp_friends,
+                            mafiapp_services,
+                            mafiapp_enemies], 5000),
+    mafiapp_sup:start_link().
+
+stop(_) -> ok.
+
+install(Nodes) ->
+    ok = mnesia:create_schema(Nodes),
+    rpc:multicall(Nodes, application, start, [mnesia]),
+    mnesia:create_table(mafiapp_friends,
+                        [{attributes, record_info(fields, mafiapp_friends)},
+                         {index, [#mafiapp_friends.expertise]},
+                         {disc_copies, Nodes}]),
+    mnesia:create_table(mafiapp_services,
+                        [{attributes, record_info(fields, mafiapp_services)},
+                         {index, [#mafiapp_services.to]},
+                         {disc_copies, Nodes},
+                         {type, bag}]),
+    mnesia:create_table(mafiapp_enemies,
+                        [{attributes, record_info(fields, mafiapp_enemies)},
+                         {disc_copies, Nodes},
+                         {local_content, true}]),
+    rpc:multicall(Nodes, application, stop, [mnesia]).
+
+add_friend(Name, Contact, Info, Expertise) ->
+    F = fun() ->
+        mnesia:write(#mafiapp_friends{name=Name,
+                                      contact=Contact,
+                                      info=Info,
+                                      expertise=Expertise})
+    end,
+    mnesia:activity(transaction, F).
+
+friend_by_name(Name) ->
+    F = fun() ->
+        case mnesia:read({mafiapp_friends, Name}) of
+            [#mafiapp_friends{contact=C, info=I, expertise=E}] ->
+                {Name,C,I,E,find_services(Name)};
+            [] ->
+                undefined
+        end
+    end,
+    mnesia:activity(transaction, F).
+
+friend_by_expertise(Expertise) ->
+    F = fun() ->
+        qlc:eval(qlc:q(
+            [{Name,C,I,E,find_services(Name)} ||
+             #mafiapp_friends{name=Name,
+                              contact=C,
+                              info=I,
+                              expertise=E} <- mnesia:table(mafiapp_friends),
+             E =:= Expertise]))
+    end,
+    mnesia:activity(transaction, F).
+
+%% Adding validation is left to the reader
+add_service(From, To, Date, Description) ->
+    F = fun() ->
+            case mnesia:read({mafiapp_friends, From}) =:= [] orelse
+                 mnesia:read({mafiapp_friends, To}) =:= [] of
+                true ->
+                    {error, unknown_friend};
+                false ->
+                    mnesia:write(#mafiapp_services{from=From,
+                                                   to=To,
+                                                   date=Date,
+                                                   description=Description})
+            end
+    end,
+    mnesia:activity(transaction,F).
+
+debts(Name) ->
+    F = fun() ->
+        QH = qlc:q(
+            [if Name =:= To -> {From,1};
+                Name =:= From -> {To,-1}
+             end || #mafiapp_services{from=From, to=To} <-
+                      mnesia:table(mafiapp_services),
+                   Name =:= To orelse Name =:= From]),
+        qlc:fold(fun({Person,N}, Dict) ->
+                  dict:update(Person, fun(X) -> X + N end, N, Dict)
+                 end,
+                 dict:new(),
+                 QH)
+    end,
+    lists:sort([{V,K} || {K,V} <- dict:to_list(mnesia:activity(transaction, F))]).
+
+add_enemy(Name, Info) ->
+    F = fun() -> mnesia:write(#mafiapp_enemies{name=Name, info=Info}) end,
+    mnesia:activity(transaction, F).
+
+find_enemy(Name) ->
+    F = fun() -> mnesia:read({mafiapp_enemies, Name}) end,
+    case mnesia:activity(transaction, F) of
+        [] -> undefined;
+        [#mafiapp_enemies{name=N, info=I}] -> {N,I}
+    end.
+
+enemy_killed(Name) ->
+    F = fun() -> mnesia:delete({mafiapp_enemies, Name}) end,
+    mnesia:activity(transaction, F).
+
+%%%%%%%%%%%%%%%
+%%% PRIVATE %%%
+%%%%%%%%%%%%%%%
+
+find_services(Name) ->
+    Match = ets:fun2ms(
+            fun(#mafiapp_services{from=From, to=To, date=D, description=Desc})
+                when From =:= Name ->
+                    {to, To, D, Desc};
+               (#mafiapp_services{from=From, to=To, date=D, description=Desc})
+                when To =:= Name ->
+                    {from, From, D, Desc}
+            end
+    ),
+    mnesia:select(mafiapp_services, Match).
diff --git a/learn-you-some-erlang/mafiapp-1.0.1/src/mafiapp_sup.erl b/learn-you-some-erlang/mafiapp-1.0.1/src/mafiapp_sup.erl
new file mode 100644
index 0000000..e31b221
--- /dev/null
+++ b/learn-you-some-erlang/mafiapp-1.0.1/src/mafiapp_sup.erl
@@ -0,0 +1,12 @@
+-module(mafiapp_sup).
+-behaviour(supervisor).
+-export([start_link/0]).
+-export([init/1]).
+
+start_link() ->
+    supervisor:start_link(?MODULE, []).
+
+%% This does absolutely nothing, only there to
+%% allow to wait for tables.
+init([]) ->
+    {ok, {{one_for_one, 1, 1}, []}}.
diff --git a/learn-you-some-erlang/mafiapp-1.0.1/test/mafiapp.spec b/learn-you-some-erlang/mafiapp-1.0.1/test/mafiapp.spec
new file mode 100644
index 0000000..4953e67
--- /dev/null
+++ b/learn-you-some-erlang/mafiapp-1.0.1/test/mafiapp.spec
@@ -0,0 +1,3 @@
+{alias, root, "./test/"}.
+{logdir, "./logs/"}.
+{suites, root, all}.
diff --git a/learn-you-some-erlang/mafiapp-1.0.1/test/mafiapp_SUITE.erl b/learn-you-some-erlang/mafiapp-1.0.1/test/mafiapp_SUITE.erl
new file mode 100644
index 0000000..6005d29
--- /dev/null
+++ b/learn-you-some-erlang/mafiapp-1.0.1/test/mafiapp_SUITE.erl
@@ -0,0 +1,128 @@
+-module(mafiapp_SUITE).
+-include_lib("common_test/include/ct.hrl").
+-export([init_per_suite/1, end_per_suite/1,
+         init_per_testcase/2, end_per_testcase/2,
+         all/0]).
+-export([add_service/1, friend_by_name/1, friend_by_expertise/1,
+         friend_with_services/1, accounts/1, enemies/1]).
+
+all() -> [add_service, friend_by_name, friend_by_expertise,
+          friend_with_services, accounts, enemies].
+
+init_per_suite(Config) ->
+    Priv = ?config(priv_dir, Config),
+    application:load(mnesia),
+    application:set_env(mnesia, dir, Priv),
+    application:load(mafiapp),
+    mafiapp:install([node()]),
+    application:start(mnesia),
+    application:start(mafiapp),
+    Config.
+
+end_per_suite(_Config) ->
+    application:stop(mnesia),
+    ok.
+
+init_per_testcase(add_service, Config) ->
+    Config;
+init_per_testcase(accounts, Config) ->
+    ok = mafiapp:add_friend("Consigliere", [], [you], consigliere),
+    Config;
+init_per_testcase(_, Config) ->
+    ok = mafiapp:add_friend("Don Corleone", [], [boss], boss),
+    Config.
+
+end_per_testcase(_, _Config) ->
+    ok.
+
+%% services can go both way: from a friend to the boss, or
+%% from the boss to a friend! A boss friend is required!
+add_service(_Config) ->
+    {error, unknown_friend} = mafiapp:add_service("from name",
+                                                  "to name",
+                                                  {1946,5,23},
+                                                  "a fake service"),
+    ok = mafiapp:add_friend("Don Corleone", [], [boss], boss),
+    ok = mafiapp:add_friend("Alan Parsons",
+                            [{twitter,"@ArtScienceSound"}],
+                            [{born, {1948,12,20}},
+                             musician, 'audio engineer',
+                             producer, "has projects"],
+                            mixing),
+    ok = mafiapp:add_service("Alan Parsons", "Don Corleone",
+                             {1973,3,1},
+                             "Helped release a Pink Floyd album").
+
+friend_by_name(_Config) ->
+    ok = mafiapp:add_friend("Pete Cityshend",
+                            [{phone, "418-542-3000"},
+                             {email, "quadrophonia@example.org"},
+                             {other, "yell real loud"}],
+                            [{born, {1945,5,19}},
+                             musician, popular],
+                            music),
+    {"Pete Cityshend",
+     _Contact, _Info, music,
+     _Services} = mafiapp:friend_by_name("Pete Cityshend"),
+    undefined = mafiapp:friend_by_name(make_ref()).
+
+friend_by_expertise(_Config) ->
+    ok = mafiapp:add_friend("A Red Panda",
+                            [{location, "in a zoo"}],
+                            [animal,cute],
+                            climbing),
+    [{"A Red Panda",
+      _Contact, _Info, climbing,
+     _Services}] = mafiapp:friend_by_expertise(climbing),
+    [] = mafiapp:friend_by_expertise(make_ref()).
+
+friend_with_services(_Config) ->
+    ok = mafiapp:add_friend("Someone", [{other, "at the fruit stand"}],
+                            [weird, mysterious], shadiness),
+    ok = mafiapp:add_service("Don Corleone", "Someone",
+                             {1949,2,14}, "Increased business"),
+    ok = mafiapp:add_service("Someone", "Don Corleone",
+                             {1949,12,25}, "Gave a Christmas gift"),
+    %% We don't care about the order. The test was made to fit
+    %% whatever the functions returned.
+    {"Someone",
+     _Contact, _Info, shadiness,
+     [{to, "Don Corleone", {1949,12,25}, "Gave a Christmas gift"},
+      {from, "Don Corleone", {1949,2,14}, "Increased business"}]} =
+    mafiapp:friend_by_name("Someone").
+
+%% It should be possible to find all people who owe us things.
+accounts(_Config) ->
+    ok = mafiapp:add_friend("Gill Bates", [{email, "ceo@macrohard.com"}],
+                            [clever,rich], computers),
+    ok = mafiapp:add_service("Consigliere", "Gill Bates",
+                             {1985,11,20}, "Bought 15 copies of software"),
+    ok = mafiapp:add_service("Gill Bates", "Consigliere",
+                             {1986,8,17}, "Made computer faster"),
+    ok = mafiapp:add_friend("Pierre Gauthier", [{other, "city arena"}],
+                            [{job, "sports team GM"}], sports),
+    ok = mafiapp:add_service("Pierre Gauthier", "Consigliere", {2009,6,30},
+                             "Took on a huge, bad contract"),
+    ok = mafiapp:add_friend("Wayne Gretzky", [{other, "Canada"}],
+                            [{born, {1961,1,26}}, "hockey legend"],
+                            hockey),
+    ok = mafiapp:add_service("Consigliere", "Wayne Gretzky", {1964,1,26},
+                             "Gave first pair of ice skates"),
+    %% Wayne Gretzky owes us something so the debt is negative
+    %% Gill Bates are equal
+    %% Gauthier is owed a service.
+    [{-1,"Wayne Gretzky"},
+     {0,"Gill Bates"},
+     {1,"Pierre Gauthier"}] = mafiapp:debts("Consigliere"),
+    [{1, "Consigliere"}] = mafiapp:debts("Wayne Gretzky").
+
+enemies(_Config) ->
+    undefined = mafiapp:find_enemy("Edward"),
+    ok = mafiapp:add_enemy("Edward", [{bio, "Vampire"},
+                                  {comment, "He sucks (blood)"}]),
+    {"Edward", [{bio, "Vampire"},
+                {comment, "He sucks (blood)"}]} =
+       mafiapp:find_enemy("Edward"),
+    ok = mafiapp:enemy_killed("Edward"),
+    undefined = mafiapp:find_enemy("Edward").
+
diff --git a/learn-you-some-erlang/multiproc.erl b/learn-you-some-erlang/multiproc.erl
new file mode 100644
index 0000000..abddaf9
--- /dev/null
+++ b/learn-you-some-erlang/multiproc.erl
@@ -0,0 +1,39 @@
+-module(multiproc).
+-compile([export_all]).
+
+sleep(T) ->
+    receive
+    after T -> ok
+    end.
+
+flush() ->
+    receive
+        _ -> flush()
+    after 0 ->
+        ok
+    end.
+
+important() ->
+    receive
+        {Priority, Message} when Priority > 10 ->
+            [Message | important()]
+    after 0 ->
+        normal()
+    end.
+
+normal() ->
+    receive
+        {_, Message} ->
+            [Message | normal()]
+    after 0 ->
+        []
+    end.
+
+%% optimized in R14A
+optimized(Pid) ->
+    Ref = make_ref(),
+    Pid ! {self(), Ref, hello},
+    receive
+        {Pid, Ref, Msg} ->
+            io:format("~p~n", [Msg])
+    end.
diff --git a/learn-you-some-erlang/musicians.erl b/learn-you-some-erlang/musicians.erl
new file mode 100644
index 0000000..e369d44
--- /dev/null
+++ b/learn-you-some-erlang/musicians.erl
@@ -0,0 +1,84 @@
+-module(musicians).
+-behaviour(gen_server).
+
+-export([start_link/2, stop/1]).
+-export([init/1, handle_call/3, handle_cast/2,
+         handle_info/2, code_change/3, terminate/2]).
+
+-record(state, {name="", role, skill=good}).
+-define(DELAY, 750).
+
+start_link(Role, Skill) ->
+    gen_server:start_link({local, Role}, ?MODULE, [Role, Skill], []).
+
+stop(Role) -> gen_server:call(Role, stop).
+
+init([Role, Skill]) ->
+    %% To know when the parent shuts down
+    process_flag(trap_exit, true),
+    %% sets a seed for random number generation for the life of the process
+    %% uses the current time to do it. Unique value guaranteed by now()
+    random:seed(now()),
+    TimeToPlay = random:uniform(3000),
+    Name = pick_name(),
+    StrRole = atom_to_list(Role),
+    io:format("Musician ~s, playing the ~s entered the room~n",
+              [Name, StrRole]),
+    {ok, #state{name=Name, role=StrRole, skill=Skill}, TimeToPlay}.
+
+handle_call(stop, _From, S=#state{}) ->
+    {stop, normal, ok, S};
+handle_call(_Message, _From, S) ->
+    {noreply, S, ?DELAY}.
+
+handle_cast(_Message, S) ->
+    {noreply, S, ?DELAY}.
+
+handle_info(timeout, S = #state{name=N, skill=good}) ->
+    io:format("~s produced sound!~n",[N]),
+    {noreply, S, ?DELAY};
+handle_info(timeout, S = #state{name=N, skill=bad}) ->
+    case random:uniform(5) of
+        1 ->
+            io:format("~s played a false note. Uh oh~n",[N]),
+            {stop, bad_note, S};
+        _ ->
+            io:format("~s produced sound!~n",[N]),
+            {noreply, S, ?DELAY}
+    end;
+handle_info(_Message, S) ->
+    {noreply, S, ?DELAY}.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+terminate(normal, S) ->
+    io:format("~s left the room (~s)~n",[S#state.name, S#state.role]);
+terminate(bad_note, S) ->
+    io:format("~s sucks! kicked that member out of the band! (~s)~n",
+              [S#state.name, S#state.role]);
+terminate(shutdown, S) ->
+    io:format("The manager is mad and fired the whole band! "
+              "~s just got back to playing in the subway~n",
+              [S#state.name]);
+terminate(_Reason, S) ->
+    io:format("~s has been kicked out (~s)~n", [S#state.name, S#state.role]).
+
+%% Yes, the names are based off the magic school bus characters
+%% 10 names!
+pick_name() ->
+    %% the seed must be set for the random functions. Use within the
+    %% process that started with init/1
+    lists:nth(random:uniform(10), firstnames())
+    ++ " " ++
+    lists:nth(random:uniform(10), lastnames()).
+
+firstnames() ->
+    ["Valerie", "Arnold", "Carlos", "Dorothy", "Keesha",
+     "Phoebe", "Ralphie", "Tim", "Wanda", "Janet"].
+
+lastnames() ->
+    ["Frizzle", "Perlstein", "Ramon", "Ann", "Franklin",
+     "Terese", "Tennelli", "Jamal", "Li", "Perlstein"].
+
+
diff --git a/learn-you-some-erlang/my_server.erl b/learn-you-some-erlang/my_server.erl
new file mode 100644
index 0000000..ed83a7a
--- /dev/null
+++ b/learn-you-some-erlang/my_server.erl
@@ -0,0 +1,42 @@
+-module(my_server).
+-export([start/2, start_link/2, call/2, cast/2, reply/2]).
+
+%%% Public API
+start(Module, InitialState) ->
+    spawn(fun() -> init(Module, InitialState) end).
+
+start_link(Module, InitialState) ->
+    spawn_link(fun() -> init(Module, InitialState) end).
+
+call(Pid, Msg) ->
+    Ref = erlang:monitor(process, Pid),
+    Pid ! {sync, self(), Ref, Msg},
+    receive
+        {Ref, Reply} ->
+            erlang:demonitor(Ref, [flush]),
+            Reply;
+        {'DOWN', Ref, process, Pid, Reason} ->
+            erlang:error(Reason)
+    after 5000 ->
+        erlang:error(timeout)
+    end.
+
+cast(Pid, Msg) ->
+    Pid ! {async, Msg},
+    ok.
+
+reply({Pid, Ref}, Reply) ->
+    Pid ! {Ref, Reply}.
+
+%%% Private stuff
+init(Module, InitialState) ->
+    loop(Module, Module:init(InitialState)).
+
+loop(Module, State) ->
+    receive
+        {async, Msg} ->
+             loop(Module, Module:handle_cast(Msg, State));
+        {sync, Pid, Ref, Msg} ->
+             loop(Module, Module:handle_call(Msg, {Pid, Ref}, State))
+    end.
+
diff --git a/learn-you-some-erlang/oop.erl b/learn-you-some-erlang/oop.erl
new file mode 100644
index 0000000..19653d3
--- /dev/null
+++ b/learn-you-some-erlang/oop.erl
@@ -0,0 +1,28 @@
+-module(oop).
+-export([animal/1, dog/1, cat/1]).
+
+%% all the method calls need to be in tuples when they have more than
+%% one argument so we can use functions of arity 1 for every call we make.
+
+animal(Name) ->
+    fun(type) -> "living thing";
+       (name) -> Name;
+       (move) -> Name++" moves around...";
+       ({eat, Item}) -> Name++" eats "++Item;
+       (_) -> "I'm sorry Dave, I can't do that."
+    end.
+
+dog(Name) ->
+    Parent = animal(Name),
+    fun(talk) -> Name++" says: Woof!";
+       ({chase, Animal}) when is_function(Animal) ->
+            Name++" chases a "++Animal(type)++" named "++Animal(name)++" around";
+       (X) -> Parent(X)
+    end.
+
+cat(Name) ->
+    Parent = animal(Name),
+    fun(type) -> "cat";
+       (talk) -> Name++" says: Meow!";
+       (X) -> Parent(X)
+    end.
diff --git a/learn-you-some-erlang/ops.erl b/learn-you-some-erlang/ops.erl
new file mode 100644
index 0000000..ccd95cd
--- /dev/null
+++ b/learn-you-some-erlang/ops.erl
@@ -0,0 +1,4 @@
+-module(ops).
+-export([add/2]).
+
+add(A,B) -> A + B.
diff --git a/learn-you-some-erlang/ops_tests.erl b/learn-you-some-erlang/ops_tests.erl
new file mode 100644
index 0000000..53323cf
--- /dev/null
+++ b/learn-you-some-erlang/ops_tests.erl
@@ -0,0 +1,25 @@
+-module(ops_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+add_test() ->
+    4 = ops:add(2,2).
+
+new_add_test() ->
+    ?assertEqual(4, ops:add(2,2)),
+    ?assertEqual(3, ops:add(1,2)),
+    ?assert(is_number(ops:add(1,2))),
+    ?assertEqual(3, ops:add(1,1)),
+    ?assertError(badarith, 1/0).
+
+add_test_() ->
+    [test_them_types(),
+     test_them_values(),
+     ?_assertError(badarith, 1/0)].
+
+test_them_types() ->
+    ?_assert(is_number(ops:add(1,2))).
+
+test_them_values() ->
+    [?_assertEqual(4, ops:add(2,2)),
+     ?_assertEqual(3, ops:add(1,2)),
+     ?_assertEqual(3, ops:add(1,1))].
diff --git a/learn-you-some-erlang/pool/ppool.erl b/learn-you-some-erlang/pool/ppool.erl
new file mode 100644
index 0000000..b5d34c0
--- /dev/null
+++ b/learn-you-some-erlang/pool/ppool.erl
@@ -0,0 +1,25 @@
+%%% API module for the pool
+-module(ppool).
+-export([start_link/0, stop/0, start_pool/3,
+         run/2, sync_queue/2, async_queue/2, stop_pool/1]).
+
+start_link() ->
+    ppool_supersup:start_link().
+
+stop() ->
+    ppool_supersup:stop().
+
+start_pool(Name, Limit, {M,F,A}) ->
+    ppool_supersup:start_pool(Name, Limit, {M,F,A}).
+
+stop_pool(Name) ->
+    ppool_supersup:stop_pool(Name).
+
+run(Name, Args) ->
+    ppool_serv:run(Name, Args).
+
+async_queue(Name, Args) ->
+    ppool_serv:async_queue(Name, Args).
+
+sync_queue(Name, Args) ->
+    ppool_serv:sync_queue(Name, Args).
diff --git a/learn-you-some-erlang/pool/ppool_nagger.erl b/learn-you-some-erlang/pool/ppool_nagger.erl
new file mode 100644
index 0000000..903f821
--- /dev/null
+++ b/learn-you-some-erlang/pool/ppool_nagger.erl
@@ -0,0 +1,50 @@
+%% demo module, a nagger for tasks,
+%% because the previous one wasn't good enough
+%%
+%% Can take:
+%% - a time delay for which to nag,
+%% - an adress to say where the messages should be sent
+%% - a message to send in the mailbox telling you what to nag,
+%%   with an id to be able to call: ->
+%% - a command to say the task is done 
+-module(ppool_nagger).
+-behaviour(gen_server).
+-export([start_link/4, stop/1]).
+-export([init/1, handle_call/3, handle_cast/2,
+         handle_info/2, code_change/3, terminate/2]).
+
+start_link(Task, Delay, Max, SendTo) ->
+    gen_server:start_link(?MODULE, {Task, Delay, Max, SendTo} , []).
+
+stop(Pid) ->
+    gen_server:call(Pid, stop).
+
+init({Task, Delay, Max, SendTo}) ->
+    process_flag(trap_exit, true), % for tests & terminate too
+    {ok, {Task, Delay, Max, SendTo}, Delay}.
+
+%%% OTP Callbacks
+handle_call(stop, _From, State) ->
+    {stop, normal, ok, State};
+handle_call(_Msg, _From, State) ->
+    {noreply, State}.
+
+handle_cast(_Msg, State) ->
+    {noreply, State}.
+
+handle_info(timeout, {Task, Delay, Max, SendTo}) ->
+    SendTo ! {self(), Task},
+    if Max =:= infinity ->
+        {noreply, {Task, Delay, Max, SendTo}, Delay};
+       Max =< 1 ->
+        {stop, normal, {Task, Delay, 0, SendTo}};
+       Max > 1  ->
+        {noreply, {Task, Delay, Max-1, SendTo}, Delay}
+    end;
+handle_info(_Msg, State) ->
+    {noreply, State}.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+terminate(_Reason, _State) -> ok.
diff --git a/learn-you-some-erlang/pool/ppool_serv.erl b/learn-you-some-erlang/pool/ppool_serv.erl
new file mode 100644
index 0000000..512b49f
--- /dev/null
+++ b/learn-you-some-erlang/pool/ppool_serv.erl
@@ -0,0 +1,113 @@
+-module(ppool_serv).
+-behaviour(gen_server).
+-export([start/4, start_link/4, run/2, sync_queue/2, async_queue/2, stop/1]).
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+         code_change/3, terminate/2]).
+
+%% The friendly supervisor is started dynamically!
+-define(SPEC(MFA),
+        {worker_sup,
+         {ppool_worker_sup, start_link, [MFA]},
+          temporary,
+          10000,
+          supervisor,
+          [ppool_worker_sup]}).
+
+-record(state, {limit=0,
+                sup,
+                refs,
+                queue=queue:new()}).
+
+start(Name, Limit, Sup, MFA) when is_atom(Name), is_integer(Limit) ->
+    gen_server:start({local, Name}, ?MODULE, {Limit, MFA, Sup}, []).
+
+start_link(Name, Limit, Sup, MFA) when is_atom(Name), is_integer(Limit) ->
+    gen_server:start_link({local, Name}, ?MODULE, {Limit, MFA, Sup}, []).
+
+run(Name, Args) ->
+    gen_server:call(Name, {run, Args}).
+
+sync_queue(Name, Args) ->
+    gen_server:call(Name, {sync, Args}, infinity).
+
+async_queue(Name, Args) ->
+    gen_server:cast(Name, {async, Args}).
+
+stop(Name) ->
+    gen_server:call(Name, stop).
+
+%% Gen server
+init({Limit, MFA, Sup}) ->
+    %% We need to find the Pid of the worker supervisor from here,
+    %% but alas, this would be calling the supervisor while it waits for us!
+    self() ! {start_worker_supervisor, Sup, MFA},
+    {ok, #state{limit=Limit, refs=gb_sets:empty()}}.
+
+handle_call({run, Args}, _From, S = #state{limit=N, sup=Sup, refs=R}) when N > 0 ->
+    {ok, Pid} = supervisor:start_child(Sup, Args),
+    Ref = erlang:monitor(process, Pid),
+    {reply, {ok,Pid}, S#state{limit=N-1, refs=gb_sets:add(Ref,R)}};
+handle_call({run, _Args}, _From, S=#state{limit=N}) when N =< 0 ->
+    {reply, noalloc, S};
+
+handle_call({sync, Args}, _From, S = #state{limit=N, sup=Sup, refs=R}) when N > 0 ->
+    {ok, Pid} = supervisor:start_child(Sup, Args),
+    Ref = erlang:monitor(process, Pid),
+    {reply, {ok,Pid}, S#state{limit=N-1, refs=gb_sets:add(Ref,R)}};
+handle_call({sync, Args},  From, S = #state{queue=Q}) ->
+    {noreply, S#state{queue=queue:in({From, Args}, Q)}};
+
+handle_call(stop, _From, State) ->
+    {stop, normal, ok, State};
+handle_call(_Msg, _From, State) ->
+    {noreply, State}.
+
+
+handle_cast({async, Args}, S=#state{limit=N, sup=Sup, refs=R}) when N > 0 ->
+    {ok, Pid} = supervisor:start_child(Sup, Args),
+    Ref = erlang:monitor(process, Pid),
+    {noreply, S#state{limit=N-1, refs=gb_sets:add(Ref,R)}};
+handle_cast({async, Args}, S=#state{limit=N, queue=Q}) when N =< 0 ->
+    {noreply, S#state{queue=queue:in(Args,Q)}};
+
+handle_cast(_Msg, State) ->
+    {noreply, State}.
+
+handle_info({'DOWN', Ref, process, _Pid, _}, S = #state{refs=Refs}) ->
+    io:format("received down msg~n"),
+    case gb_sets:is_element(Ref, Refs) of
+        true ->
+            handle_down_worker(Ref, S);
+        false -> %% Not our responsibility
+            {noreply, S}
+    end;
+handle_info({start_worker_supervisor, Sup, MFA}, S = #state{}) ->
+    {ok, Pid} = supervisor:start_child(Sup, ?SPEC(MFA)),
+    link(Pid),
+    {noreply, S#state{sup=Pid}};
+handle_info(Msg, State) ->
+    io:format("Unknown msg: ~p~n", [Msg]),
+    {noreply, State}.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+terminate(_Reason, _State) ->
+    ok.
+
+handle_down_worker(Ref, S = #state{limit=L, sup=Sup, refs=Refs}) ->
+    case queue:out(S#state.queue) of
+        {{value, {From, Args}}, Q} ->
+            {ok, Pid} = supervisor:start_child(Sup, Args),
+            NewRef = erlang:monitor(process, Pid),
+            NewRefs = gb_sets:insert(NewRef, gb_sets:delete(Ref,Refs)),
+            gen_server:reply(From, {ok, Pid}),
+            {noreply, S#state{refs=NewRefs, queue=Q}};
+        {{value, Args}, Q} ->
+            {ok, Pid} = supervisor:start_child(Sup, Args),
+            NewRef = erlang:monitor(process, Pid),
+            NewRefs = gb_sets:insert(NewRef, gb_sets:delete(Ref,Refs)),
+            {noreply, S#state{refs=NewRefs, queue=Q}};
+        {empty, _} ->
+            {noreply, S#state{limit=L+1, refs=gb_sets:delete(Ref,Refs)}}
+    end.
diff --git a/learn-you-some-erlang/pool/ppool_sup.erl b/learn-you-some-erlang/pool/ppool_sup.erl
new file mode 100644
index 0000000..71ec31d
--- /dev/null
+++ b/learn-you-some-erlang/pool/ppool_sup.erl
@@ -0,0 +1,17 @@
+-module(ppool_sup).
+-export([start_link/3, init/1]).
+-behaviour(supervisor).
+
+start_link(Name, Limit, MFA) ->
+    supervisor:start_link(?MODULE, {Name, Limit, MFA}).
+
+init({Name, Limit, MFA}) ->
+    MaxRestart = 1,
+    MaxTime = 3000,
+    {ok, {{one_for_all, MaxRestart, MaxTime},
+          [{serv,
+             {ppool_serv, start_link, [Name, Limit, self(), MFA]},
+             permanent,
+             5000, 
+             worker,
+             [ppool_serv]}]}}.
diff --git a/learn-you-some-erlang/pool/ppool_supersup.erl b/learn-you-some-erlang/pool/ppool_supersup.erl
new file mode 100644
index 0000000..5790c5f
--- /dev/null
+++ b/learn-you-some-erlang/pool/ppool_supersup.erl
@@ -0,0 +1,31 @@
+-module(ppool_supersup).
+-behaviour(supervisor).
+-export([start_link/0, stop/0, start_pool/3, stop_pool/1]).
+-export([init/1]).
+
+start_link() ->
+    supervisor:start_link({local, ppool}, ?MODULE, []).
+
+%% technically, a supervisor can not be killed in an easy way.
+%% Let's do it brutally!
+stop() ->
+    case whereis(ppool) of
+        P when is_pid(P) ->
+            exit(P, kill);
+        _ -> ok
+    end.
+
+start_pool(Name, Limit, MFA) ->
+    ChildSpec = {Name,
+                 {ppool_sup, start_link, [Name, Limit, MFA]},
+                  permanent, 10500, supervisor, [ppool_sup]},
+    supervisor:start_child(ppool, ChildSpec).
+
+stop_pool(Name) ->
+    supervisor:terminate_child(ppool, Name),
+    supervisor:delete_child(ppool, Name).
+
+init([]) ->
+    MaxRestart = 6,
+    MaxTime = 3000,
+    {ok, {{one_for_one, MaxRestart, MaxTime}, []}}.
diff --git a/learn-you-some-erlang/pool/ppool_tests.erl b/learn-you-some-erlang/pool/ppool_tests.erl
new file mode 100644
index 0000000..7cec6d0
--- /dev/null
+++ b/learn-you-some-erlang/pool/ppool_tests.erl
@@ -0,0 +1,200 @@
+-module(ppool_tests).
+-include_lib("eunit/include/eunit.hrl").
+-export([test_mfa/1, wait_mfa/1]).
+
+%%% All Test Fixtures
+start_test_() ->
+    {"It should be possible to start a pool server and give it a name",
+     {setup,
+      fun find_unique_name/0,
+      fun(Name) ->
+        [start_and_test_name(Name)]
+      end}}.
+
+mfa_test_() ->
+    {"A pool process can be allocated which will be ordered "
+     "to run an MFA call determined at start time, with arguments "
+     "provided at call time",
+     {setup,
+      fun start_ppool/0,
+      fun kill_ppool/1,
+      fun(Name) ->
+        [pool_run_mfa(Name)]
+      end}
+    }.
+
+alloc_test_() ->
+    {"A pool process can be allocated which will be ordered "
+     "to run a worker, only if there are enough which "
+     "haven't been ordered to run yet.",
+     {setup,
+      fun start_ppool/0,
+      fun kill_ppool/1,
+      fun(Name) ->
+        [pool_run_alloc(Name),
+         pool_run_noalloc(Name)]
+      end}
+    }.
+
+realloc_test_() ->
+    {"When an allocated process dies, "
+     "A new one can be allocated to replace it.",
+     {setup,
+      fun start_ppool/0,
+      fun kill_ppool/1,
+      fun(Name) ->
+        [pool_run_realloc(Name)]
+      end}
+    }.
+
+queue_test_() ->
+    {"The queue function can be used to run the function as soon as possible. "
+     "If no space is available, the worker call is added to the queue.",
+     {foreach,
+      fun start_ppool/0,
+      fun kill_ppool/1,
+      [fun(Name) -> test_async_queue(Name) end,
+       fun(Name) -> test_sync_queue(Name) end]}
+    }.
+
+supervision_test_() ->
+    {"The ppool will never restart a dead child, but all children (OTP "
+     "compliant) will be shut down when closing the pool, even if they "
+     "are trapping exits",
+     {setup,
+      fun find_unique_name/0,
+      fun test_supervision/1}}.
+    
+auth_test_() ->
+    {"The ppool should only dequeue tasks after receiving a down signal "
+     "from a worker and nobody else",
+     {setup,
+      fun start_ppool/0,
+      fun kill_ppool/1,
+      fun test_auth_dealloc/1}}.
+
+%%% Setups/teardowns
+find_unique_name() ->
+    ppool:start_link(),
+    Name = list_to_atom(lists:flatten(io_lib:format("~p",[now()]))),
+    ?assertEqual(undefined, whereis(Name)),
+    Name.
+
+start_ppool() ->
+    Name = find_unique_name(),
+    ppool:start_pool(Name, 2, {ppool_nagger, start_link, []}),
+    Name.
+
+kill_ppool(Name) ->
+    ppool:stop_pool(Name).
+    
+%%% Actual tests
+start_and_test_name(Name) ->
+    ppool:start_pool(Name, 1, {ppool_nagger, start_link, []}),
+    A = whereis(Name),
+    ppool:stop_pool(Name),
+    timer:sleep(100),
+    B = whereis(Name),
+    [?_assert(undefined =/= A),
+     ?_assertEqual(undefined, B)].
+
+pool_run_mfa(Name) ->
+    ppool:run(Name, [i_am_running, 1, 1, self()]),
+    X = receive
+        {_Pid, i_am_running} -> ok
+    after 3000 ->
+        timeout
+    end,
+    ?_assertEqual(ok, X).
+
+pool_run_alloc(Name) ->
+    {ok, Pid} = ppool:run(Name, [i_am_running, 1, 1, self()]),
+    X = receive
+        {Pid, i_am_running} -> ok
+    after 3000 ->
+        timeout
+    end,
+    [?_assert(is_pid(Pid)),
+     ?_assertEqual(ok, X)].
+
+pool_run_noalloc(Name) ->
+    %% Init function should have set the limit to 2
+    ppool:run(Name, [i_am_running, 300, 1, self()]),
+    ppool:run(Name, [i_am_running, 300, 1, self()]),
+    X = ppool:run(Name, [i_am_running, 1, 1, self()]),
+    ?_assertEqual(noalloc, X).
+    
+pool_run_realloc(Name) ->
+    %% Init function should have set the limit to 2
+    {ok, A} = ppool:run(Name, [i_am_running, 500, 1, self()]),
+    timer:sleep(100),
+    {ok, B} = ppool:run(Name, [i_am_running, 500, 1, self()]),
+    timer:sleep(600),
+    {ok, Pid} = ppool:run(Name, [i_am_running, 1, 1, self()]),
+    timer:sleep(100),
+    L = flush(),
+    [?_assert(is_pid(Pid)),
+     ?_assertEqual([{A,i_am_running}, {B,i_am_running}, {Pid,i_am_running}],
+                   L)].
+
+test_async_queue(Name) ->
+    %% Still two elements max!
+    ok = ppool:async_queue(Name, [i_am_running, 2000, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 2000, 1, self()]),
+    noalloc = ppool:run(Name, [i_am_running, 2000, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 500, 1, self()]),
+    timer:sleep(3500),
+    L = flush(),
+    ?_assertMatch([{_, i_am_running}, {_, i_am_running}, {_, i_am_running}], L).
+
+test_sync_queue(Name) ->
+    %% Hell yase, two max
+    {ok, Pid} = ppool:sync_queue(Name, [i_am_running, 200, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 200, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 200, 1, self()]),
+    {ok, Pid2} = ppool:sync_queue(Name, [i_am_running, 100, 1, self()]),
+    timer:sleep(300),
+    L = flush(),
+    [?_assert(is_pid(Pid)),
+     ?_assert(is_pid(Pid2)),
+     ?_assertMatch([{_,i_am_running}, {_,i_am_running},
+                    {_,i_am_running}, {_,i_am_running}],
+                   L)].
+
+test_supervision(Name) ->
+    ppool:start_pool(Name, 1, {ppool_nagger, start_link, []}),
+    {ok, Pid} = ppool:run(Name, [sup, 10000, 100, self()]),
+    ppool:stop_pool(Name),
+    timer:sleep(100),
+    ?_assertEqual(undefined, process_info(Pid)). 
+
+test_auth_dealloc(Name) ->
+    %% Hell yase, two max
+    {ok, _Pid} = ppool:sync_queue(Name, [i_am_running, 500, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 10000, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 10000, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 1, 1, self()]),
+    timer:sleep(600),
+    Name ! {'DOWN', make_ref(), process, self(), normal},
+    Name ! {'DOWN', make_ref(), process, self(), normal},
+    Name ! {'DOWN', make_ref(), process, self(), normal},
+    timer:sleep(200),
+    L = flush(),
+    ?_assertMatch([{_,i_am_running}], L).
+    
+
+
+flush() ->
+    receive
+        X -> [X|flush()]
+    after 0 ->
+        []
+    end.
+
+%% Exported Helper functions
+test_mfa(Pid) ->
+    Pid ! i_am_running.
+
+wait_mfa(Pid) ->
+    Pid ! i_am_running,
+    timer:sleep(3000).
diff --git a/learn-you-some-erlang/pool/ppool_worker_sup.erl b/learn-you-some-erlang/pool/ppool_worker_sup.erl
new file mode 100644
index 0000000..2467c47
--- /dev/null
+++ b/learn-you-some-erlang/pool/ppool_worker_sup.erl
@@ -0,0 +1,15 @@
+-module(ppool_worker_sup).
+-export([start_link/1, init/1]).
+-behaviour(supervisor).
+
+start_link(MFA = {_,_,_}) ->
+    supervisor:start_link(?MODULE, MFA).
+
+init({M,F,A}) ->
+    MaxRestart = 5,
+    MaxTime = 3600,
+    {ok, {{simple_one_for_one, MaxRestart, MaxTime},
+          [{ppool_worker,
+            {M,F,A},
+            temporary, 5000, worker, [M]}]}}.
+    
diff --git a/learn-you-some-erlang/ppool-1.0/Emakefile b/learn-you-some-erlang/ppool-1.0/Emakefile
new file mode 100644
index 0000000..8e1f951
--- /dev/null
+++ b/learn-you-some-erlang/ppool-1.0/Emakefile
@@ -0,0 +1,2 @@
+{"src/*", [debug_info, {i,"include/"}, {outdir, "ebin/"}]}.
+{"test/*", [debug_info, {i,"include/"}, {outdir, "ebin/"}]}.
diff --git a/learn-you-some-erlang/ppool-1.0/ebin/ppool.app b/learn-you-some-erlang/ppool-1.0/ebin/ppool.app
new file mode 100644
index 0000000..a791f54
--- /dev/null
+++ b/learn-you-some-erlang/ppool-1.0/ebin/ppool.app
@@ -0,0 +1,6 @@
+{application, ppool,
+ [{vsn, "1.0.0"},
+  {modules, [ppool, ppool_serv, ppool_sup, ppool_supersup, ppool_worker_sup]},
+  {registered, [ppool]},
+  {mod, {ppool, []}}
+ ]}.
diff --git a/learn-you-some-erlang/ppool-1.0/src/ppool.erl b/learn-you-some-erlang/ppool-1.0/src/ppool.erl
new file mode 100644
index 0000000..5723f98
--- /dev/null
+++ b/learn-you-some-erlang/ppool-1.0/src/ppool.erl
@@ -0,0 +1,26 @@
+%%% API module for the pool
+-module(ppool).
+-behaviour(application).
+-export([start/2, stop/1, start_pool/3,
+         run/2, sync_queue/2, async_queue/2, stop_pool/1]).
+
+start(normal, _Args) ->
+    ppool_supersup:start_link().
+
+stop(_State) ->
+    ok.
+
+start_pool(Name, Limit, {M,F,A}) ->
+    ppool_supersup:start_pool(Name, Limit, {M,F,A}).
+
+stop_pool(Name) ->
+    ppool_supersup:stop_pool(Name).
+
+run(Name, Args) ->
+    ppool_serv:run(Name, Args).
+
+async_queue(Name, Args) ->
+    ppool_serv:async_queue(Name, Args).
+
+sync_queue(Name, Args) ->
+    ppool_serv:sync_queue(Name, Args).
diff --git a/learn-you-some-erlang/ppool-1.0/src/ppool_serv.erl b/learn-you-some-erlang/ppool-1.0/src/ppool_serv.erl
new file mode 100644
index 0000000..a16130c
--- /dev/null
+++ b/learn-you-some-erlang/ppool-1.0/src/ppool_serv.erl
@@ -0,0 +1,112 @@
+-module(ppool_serv).
+-behaviour(gen_server).
+-export([start/4, start_link/4, run/2, sync_queue/2, async_queue/2, stop/1]).
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+         code_change/3, terminate/2]).
+
+%% The friendly supervisor is started dynamically!
+-define(SPEC(MFA),
+        {worker_sup,
+         {ppool_worker_sup, start_link, [MFA]},
+          temporary,
+          10000,
+          supervisor,
+          [ppool_worker_sup]}).
+
+-record(state, {limit=0,
+                sup,
+                refs,
+                queue=queue:new()}).
+
+start(Name, Limit, Sup, MFA) when is_atom(Name), is_integer(Limit) ->
+    gen_server:start({local, Name}, ?MODULE, {Limit, MFA, Sup}, []).
+
+start_link(Name, Limit, Sup, MFA) when is_atom(Name), is_integer(Limit) ->
+    gen_server:start_link({local, Name}, ?MODULE, {Limit, MFA, Sup}, []).
+
+run(Name, Args) ->
+    gen_server:call(Name, {run, Args}).
+
+sync_queue(Name, Args) ->
+    gen_server:call(Name, {sync, Args}, infinity).
+
+async_queue(Name, Args) ->
+    gen_server:cast(Name, {async, Args}).
+
+stop(Name) ->
+    gen_server:call(Name, stop).
+
+%% Gen server
+init({Limit, MFA, Sup}) ->
+    %% We need to find the Pid of the worker supervisor from here,
+    %% but alas, this would be calling the supervisor while it waits for us!
+    self() ! {start_worker_supervisor, Sup, MFA},
+    {ok, #state{limit=Limit, refs=gb_sets:empty()}}.
+
+handle_call({run, Args}, _From, S = #state{limit=N, sup=Sup, refs=R}) when N > 0 ->
+    {ok, Pid} = supervisor:start_child(Sup, Args),
+    Ref = erlang:monitor(process, Pid),
+    {reply, {ok,Pid}, S#state{limit=N-1, refs=gb_sets:add(Ref,R)}};
+handle_call({run, _Args}, _From, S=#state{limit=N}) when N =< 0 ->
+    {reply, noalloc, S};
+
+handle_call({sync, Args}, _From, S = #state{limit=N, sup=Sup, refs=R}) when N > 0 ->
+    {ok, Pid} = supervisor:start_child(Sup, Args),
+    Ref = erlang:monitor(process, Pid),
+    {reply, {ok,Pid}, S#state{limit=N-1, refs=gb_sets:add(Ref,R)}};
+handle_call({sync, Args},  From, S = #state{queue=Q}) ->
+    {noreply, S#state{queue=queue:in({From, Args}, Q)}};
+
+handle_call(stop, _From, State) ->
+    {stop, normal, ok, State};
+handle_call(_Msg, _From, State) ->
+    {noreply, State}.
+
+
+handle_cast({async, Args}, S=#state{limit=N, sup=Sup, refs=R}) when N > 0 ->
+    {ok, Pid} = supervisor:start_child(Sup, Args),
+    Ref = erlang:monitor(process, Pid),
+    {noreply, S#state{limit=N-1, refs=gb_sets:add(Ref,R)}};
+handle_cast({async, Args}, S=#state{limit=N, queue=Q}) when N =< 0 ->
+    {noreply, S#state{queue=queue:in(Args,Q)}};
+
+handle_cast(_Msg, State) ->
+    {noreply, State}.
+
+handle_info({'DOWN', Ref, process, _Pid, _}, S = #state{refs=Refs}) ->
+    case gb_sets:is_element(Ref, Refs) of
+        true ->
+            handle_down_worker(Ref, S);
+        false -> %% Not our responsibility
+            {noreply, S}
+    end;
+handle_info({start_worker_supervisor, Sup, MFA}, S = #state{}) ->
+    {ok, Pid} = supervisor:start_child(Sup, ?SPEC(MFA)),
+    link(Pid),
+    {noreply, S#state{sup=Pid}};
+handle_info(Msg, State) ->
+    io:format("Unknown msg: ~p~n", [Msg]),
+    {noreply, State}.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+terminate(_Reason, _State) ->
+    ok.
+
+handle_down_worker(Ref, S = #state{limit=L, sup=Sup, refs=Refs}) ->
+    case queue:out(S#state.queue) of
+        {{value, {From, Args}}, Q} ->
+            {ok, Pid} = supervisor:start_child(Sup, Args),
+            NewRef = erlang:monitor(process, Pid),
+            NewRefs = gb_sets:insert(NewRef, gb_sets:delete(Ref,Refs)),
+            gen_server:reply(From, {ok, Pid}),
+            {noreply, S#state{refs=NewRefs, queue=Q}};
+        {{value, Args}, Q} ->
+            {ok, Pid} = supervisor:start_child(Sup, Args),
+            NewRef = erlang:monitor(process, Pid),
+            NewRefs = gb_sets:insert(NewRef, gb_sets:delete(Ref,Refs)),
+            {noreply, S#state{refs=NewRefs, queue=Q}};
+        {empty, _} ->
+            {noreply, S#state{limit=L+1, refs=gb_sets:delete(Ref,Refs)}}
+    end.
diff --git a/learn-you-some-erlang/ppool-1.0/src/ppool_sup.erl b/learn-you-some-erlang/ppool-1.0/src/ppool_sup.erl
new file mode 100644
index 0000000..71ec31d
--- /dev/null
+++ b/learn-you-some-erlang/ppool-1.0/src/ppool_sup.erl
@@ -0,0 +1,17 @@
+-module(ppool_sup).
+-export([start_link/3, init/1]).
+-behaviour(supervisor).
+
+start_link(Name, Limit, MFA) ->
+    supervisor:start_link(?MODULE, {Name, Limit, MFA}).
+
+init({Name, Limit, MFA}) ->
+    MaxRestart = 1,
+    MaxTime = 3000,
+    {ok, {{one_for_all, MaxRestart, MaxTime},
+          [{serv,
+             {ppool_serv, start_link, [Name, Limit, self(), MFA]},
+             permanent,
+             5000, 
+             worker,
+             [ppool_serv]}]}}.
diff --git a/learn-you-some-erlang/ppool-1.0/src/ppool_supersup.erl b/learn-you-some-erlang/ppool-1.0/src/ppool_supersup.erl
new file mode 100644
index 0000000..06fa0af
--- /dev/null
+++ b/learn-you-some-erlang/ppool-1.0/src/ppool_supersup.erl
@@ -0,0 +1,22 @@
+-module(ppool_supersup).
+-behaviour(supervisor).
+-export([start_link/0, start_pool/3, stop_pool/1]).
+-export([init/1]).
+
+start_link() ->
+    supervisor:start_link({local, ppool}, ?MODULE, []).
+
+start_pool(Name, Limit, MFA) ->
+    ChildSpec = {Name,
+                 {ppool_sup, start_link, [Name, Limit, MFA]},
+                  permanent, 10500, supervisor, [ppool_sup]},
+    supervisor:start_child(ppool, ChildSpec).
+
+stop_pool(Name) ->
+    supervisor:terminate_child(ppool, Name),
+    supervisor:delete_child(ppool, Name).
+
+init([]) ->
+    MaxRestart = 6,
+    MaxTime = 3000,
+    {ok, {{one_for_one, MaxRestart, MaxTime}, []}}.
diff --git a/learn-you-some-erlang/ppool-1.0/src/ppool_worker_sup.erl b/learn-you-some-erlang/ppool-1.0/src/ppool_worker_sup.erl
new file mode 100644
index 0000000..2467c47
--- /dev/null
+++ b/learn-you-some-erlang/ppool-1.0/src/ppool_worker_sup.erl
@@ -0,0 +1,15 @@
+-module(ppool_worker_sup).
+-export([start_link/1, init/1]).
+-behaviour(supervisor).
+
+start_link(MFA = {_,_,_}) ->
+    supervisor:start_link(?MODULE, MFA).
+
+init({M,F,A}) ->
+    MaxRestart = 5,
+    MaxTime = 3600,
+    {ok, {{simple_one_for_one, MaxRestart, MaxTime},
+          [{ppool_worker,
+            {M,F,A},
+            temporary, 5000, worker, [M]}]}}.
+    
diff --git a/learn-you-some-erlang/ppool-1.0/test/ppool_nagger.erl b/learn-you-some-erlang/ppool-1.0/test/ppool_nagger.erl
new file mode 100644
index 0000000..903f821
--- /dev/null
+++ b/learn-you-some-erlang/ppool-1.0/test/ppool_nagger.erl
@@ -0,0 +1,50 @@
+%% demo module, a nagger for tasks,
+%% because the previous one wasn't good enough
+%%
+%% Can take:
+%% - a time delay for which to nag,
+%% - an adress to say where the messages should be sent
+%% - a message to send in the mailbox telling you what to nag,
+%%   with an id to be able to call: ->
+%% - a command to say the task is done 
+-module(ppool_nagger).
+-behaviour(gen_server).
+-export([start_link/4, stop/1]).
+-export([init/1, handle_call/3, handle_cast/2,
+         handle_info/2, code_change/3, terminate/2]).
+
+start_link(Task, Delay, Max, SendTo) ->
+    gen_server:start_link(?MODULE, {Task, Delay, Max, SendTo} , []).
+
+stop(Pid) ->
+    gen_server:call(Pid, stop).
+
+init({Task, Delay, Max, SendTo}) ->
+    process_flag(trap_exit, true), % for tests & terminate too
+    {ok, {Task, Delay, Max, SendTo}, Delay}.
+
+%%% OTP Callbacks
+handle_call(stop, _From, State) ->
+    {stop, normal, ok, State};
+handle_call(_Msg, _From, State) ->
+    {noreply, State}.
+
+handle_cast(_Msg, State) ->
+    {noreply, State}.
+
+handle_info(timeout, {Task, Delay, Max, SendTo}) ->
+    SendTo ! {self(), Task},
+    if Max =:= infinity ->
+        {noreply, {Task, Delay, Max, SendTo}, Delay};
+       Max =< 1 ->
+        {stop, normal, {Task, Delay, 0, SendTo}};
+       Max > 1  ->
+        {noreply, {Task, Delay, Max-1, SendTo}, Delay}
+    end;
+handle_info(_Msg, State) ->
+    {noreply, State}.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+terminate(_Reason, _State) -> ok.
diff --git a/learn-you-some-erlang/ppool-1.0/test/ppool_tests.erl b/learn-you-some-erlang/ppool-1.0/test/ppool_tests.erl
new file mode 100644
index 0000000..8f0dfe2
--- /dev/null
+++ b/learn-you-some-erlang/ppool-1.0/test/ppool_tests.erl
@@ -0,0 +1,200 @@
+-module(ppool_tests).
+-include_lib("eunit/include/eunit.hrl").
+-export([test_mfa/1, wait_mfa/1]).
+
+%%% All Test Fixtures
+start_test_() ->
+    {"It should be possible to start a pool server and give it a name",
+     {setup,
+      fun find_unique_name/0,
+      fun(Name) ->
+        [start_and_test_name(Name)]
+      end}}.
+
+mfa_test_() ->
+    {"A pool process can be allocated which will be ordered "
+     "to run an MFA call determined at start time, with arguments "
+     "provided at call time",
+     {setup,
+      fun start_ppool/0,
+      fun kill_ppool/1,
+      fun(Name) ->
+        [pool_run_mfa(Name)]
+      end}
+    }.
+
+alloc_test_() ->
+    {"A pool process can be allocated which will be ordered "
+     "to run a worker, only if there are enough which "
+     "haven't been ordered to run yet.",
+     {setup,
+      fun start_ppool/0,
+      fun kill_ppool/1,
+      fun(Name) ->
+        [pool_run_alloc(Name),
+         pool_run_noalloc(Name)]
+      end}
+    }.
+
+realloc_test_() ->
+    {"When an allocated process dies, "
+     "A new one can be allocated to replace it.",
+     {setup,
+      fun start_ppool/0,
+      fun kill_ppool/1,
+      fun(Name) ->
+        [pool_run_realloc(Name)]
+      end}
+    }.
+
+queue_test_() ->
+    {"The queue function can be used to run the function as soon as possible. "
+     "If no space is available, the worker call is added to the queue.",
+     {foreach,
+      fun start_ppool/0,
+      fun kill_ppool/1,
+      [fun(Name) -> test_async_queue(Name) end,
+       fun(Name) -> test_sync_queue(Name) end]}
+    }.
+
+supervision_test_() ->
+    {"The ppool will never restart a dead child, but all children (OTP "
+     "compliant) will be shut down when closing the pool, even if they "
+     "are trapping exits",
+     {setup,
+      fun find_unique_name/0,
+      fun test_supervision/1}}.
+    
+auth_test_() ->
+    {"The ppool should only dequeue tasks after receiving a down signal "
+     "from a worker and nobody else",
+     {setup,
+      fun start_ppool/0,
+      fun kill_ppool/1,
+      fun test_auth_dealloc/1}}.
+
+%%% Setups/teardowns
+find_unique_name() ->
+    application:start(ppool),
+    Name = list_to_atom(lists:flatten(io_lib:format("~p",[now()]))),
+    ?assertEqual(undefined, whereis(Name)),
+    Name.
+
+start_ppool() ->
+    Name = find_unique_name(),
+    ppool:start_pool(Name, 2, {ppool_nagger, start_link, []}),
+    Name.
+
+kill_ppool(Name) ->
+    ppool:stop_pool(Name).
+    
+%%% Actual tests
+start_and_test_name(Name) ->
+    ppool:start_pool(Name, 1, {ppool_nagger, start_link, []}),
+    A = whereis(Name),
+    ppool:stop_pool(Name),
+    timer:sleep(100),
+    B = whereis(Name),
+    [?_assert(undefined =/= A),
+     ?_assertEqual(undefined, B)].
+
+pool_run_mfa(Name) ->
+    ppool:run(Name, [i_am_running, 1, 1, self()]),
+    X = receive
+        {_Pid, i_am_running} -> ok
+    after 3000 ->
+        timeout
+    end,
+    ?_assertEqual(ok, X).
+
+pool_run_alloc(Name) ->
+    {ok, Pid} = ppool:run(Name, [i_am_running, 1, 1, self()]),
+    X = receive
+        {Pid, i_am_running} -> ok
+    after 3000 ->
+        timeout
+    end,
+    [?_assert(is_pid(Pid)),
+     ?_assertEqual(ok, X)].
+
+pool_run_noalloc(Name) ->
+    %% Init function should have set the limit to 2
+    ppool:run(Name, [i_am_running, 300, 1, self()]),
+    ppool:run(Name, [i_am_running, 300, 1, self()]),
+    X = ppool:run(Name, [i_am_running, 1, 1, self()]),
+    ?_assertEqual(noalloc, X).
+    
+pool_run_realloc(Name) ->
+    %% Init function should have set the limit to 2
+    {ok, A} = ppool:run(Name, [i_am_running, 500, 1, self()]),
+    timer:sleep(100),
+    {ok, B} = ppool:run(Name, [i_am_running, 500, 1, self()]),
+    timer:sleep(600),
+    {ok, Pid} = ppool:run(Name, [i_am_running, 1, 1, self()]),
+    timer:sleep(100),
+    L = flush(),
+    [?_assert(is_pid(Pid)),
+     ?_assertEqual([{A,i_am_running}, {B,i_am_running}, {Pid,i_am_running}],
+                   L)].
+
+test_async_queue(Name) ->
+    %% Still two elements max!
+    ok = ppool:async_queue(Name, [i_am_running, 2000, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 2000, 1, self()]),
+    noalloc = ppool:run(Name, [i_am_running, 2000, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 500, 1, self()]),
+    timer:sleep(3500),
+    L = flush(),
+    ?_assertMatch([{_, i_am_running}, {_, i_am_running}, {_, i_am_running}], L).
+
+test_sync_queue(Name) ->
+    %% Hell yase, two max
+    {ok, Pid} = ppool:sync_queue(Name, [i_am_running, 200, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 200, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 200, 1, self()]),
+    {ok, Pid2} = ppool:sync_queue(Name, [i_am_running, 100, 1, self()]),
+    timer:sleep(300),
+    L = flush(),
+    [?_assert(is_pid(Pid)),
+     ?_assert(is_pid(Pid2)),
+     ?_assertMatch([{_,i_am_running}, {_,i_am_running},
+                    {_,i_am_running}, {_,i_am_running}],
+                   L)].
+
+test_supervision(Name) ->
+    ppool:start_pool(Name, 1, {ppool_nagger, start_link, []}),
+    {ok, Pid} = ppool:run(Name, [sup, 10000, 100, self()]),
+    ppool:stop_pool(Name),
+    timer:sleep(100),
+    ?_assertEqual(undefined, process_info(Pid)). 
+
+test_auth_dealloc(Name) ->
+    %% Hell yase, two max
+    {ok, _Pid} = ppool:sync_queue(Name, [i_am_running, 500, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 10000, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 10000, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 1, 1, self()]),
+    timer:sleep(600),
+    Name ! {'DOWN', make_ref(), process, self(), normal},
+    Name ! {'DOWN', make_ref(), process, self(), normal},
+    Name ! {'DOWN', make_ref(), process, self(), normal},
+    timer:sleep(200),
+    L = flush(),
+    ?_assertMatch([{_,i_am_running}], L).
+    
+
+
+flush() ->
+    receive
+        X -> [X|flush()]
+    after 0 ->
+        []
+    end.
+
+%% Exported Helper functions
+test_mfa(Pid) ->
+    Pid ! i_am_running.
+
+wait_mfa(Pid) ->
+    Pid ! i_am_running,
+    timer:sleep(3000).
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/Emakefile b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/Emakefile
new file mode 100644
index 0000000..b203ea3
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/Emakefile
@@ -0,0 +1,2 @@
+{["src/*", "test/*"],
+ [{i,"include"}, {outdir, "ebin"}]}.
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/ebin/.this-file-intentionally-left-blank b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/ebin/.this-file-intentionally-left-blank
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/ebin/.this-file-intentionally-left-blank
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/ebin/processquest.app b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/ebin/processquest.app
new file mode 100644
index 0000000..abda4b2
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/ebin/processquest.app
@@ -0,0 +1,7 @@
+{application, processquest,
+ [{description, "Game inspired by the Progress Quest game (http://progressquest.com)"},
+  {vsn, "1.0.0"},
+  {mod, {processquest, []}},
+  {registered, [pq_supersup]},
+  {modules, [processquest, pq_stats, pq_enemy, pq_events, pq_player]},
+  {applications, [stdlib, kernel, regis, crypto]}]}.
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/include/.this-file-intentionally-left-blank b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/include/.this-file-intentionally-left-blank
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/include/.this-file-intentionally-left-blank
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/priv/.this-file-intentionally-left-blank b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/priv/.this-file-intentionally-left-blank
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/priv/.this-file-intentionally-left-blank
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_enemy.erl b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_enemy.erl
new file mode 100644
index 0000000..6f8e9b3
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_enemy.erl
@@ -0,0 +1,17 @@
+%% Gives random enemies
+-module(pq_enemy).
+-export([fetch/0]).
+
+fetch() ->
+    L = enemies(),
+    lists:nth(random:uniform(length(L)), L).
+
+enemies() ->
+    [{<<"Ant">>, [{drop, {<<"Ant Egg">>, 1}}, {experience, 1}]},
+     {<<"Wildcat">>, [{drop, {<<"Pelt">>, 1}}, {experience, 1}]},
+     {<<"Pig">>, [{drop, {<<"Bacon">>, 1}}, {experience, 1}]},
+     {<<"Wild Pig">>, [{drop, {<<"Tasty Ribs">>, 2}}, {experience, 1}]},
+     {<<"Goblin">>, [{drop, {<<"Goblin hair">>, 1}}, {experience, 2}]},
+     {<<"Robot">>, [{drop, {<<"Chunks of Metal">>, 3}}, {experience, 2}]}].
+
+
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_events.erl b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_events.erl
new file mode 100644
index 0000000..324c432
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_events.erl
@@ -0,0 +1,49 @@
+%%% Wrapper module for the event manager of ProgressQuest players.
+%%% It adds a few functions to wrap the events and sleep on the right
+%%% scale on behalf of the pq_player process.
+-module(pq_events).
+-export([killed/3, location/3, lvl_up/5, buy/4, sell/3]).
+-export([start_link/1, stop/1, add_handler/3, delete_handler/3, notify/2]).
+
+start_link(Name) ->
+    {ok, Pid} = gen_event:start_link(),
+    ok = regis:register({events, Name}, Pid),
+    {ok, Pid}.
+
+stop(Name) ->
+    ManagerPid = regis:whereis({events, Name}),
+    gen_event:stop(ManagerPid).
+
+add_handler(Name, Handler, Args) ->
+    ManagerPid = regis:whereis({events, Name}),
+    gen_event:add_handler(ManagerPid, Handler, Args).
+
+delete_handler(Name, Handler, Args) ->  
+    ManagerPid = regis:whereis({events, Name}),
+    gen_event:delete_handler(ManagerPid, Handler, Args).
+
+notify(Name, Msg) ->
+    ManagerPid = regis:whereis({events, Name}),
+    gen_event:notify(ManagerPid, Msg).
+
+killed(Name, Enemy = {_EnemyName, _Props}, Time) ->
+    notify(Name, {Name, killed, Time*2, Enemy}),
+    timer:sleep(Time*2).
+    
+location(Name, Place, Time) ->
+    notify(Name, {Name, heading, Time, Place}), 
+    timer:sleep(Time).
+
+lvl_up(Name, NewStats, NewLvl, NewExp, _Time) ->
+    notify(Name, {Name, lvl_up, 0, NewStats, NewLvl, NewExp}),
+    ok.
+
+buy(Name, Slot, Item, Time) ->
+    T = round(Time/2),
+    notify(Name, {Name, buy, T, Slot, Item}),
+    timer:sleep(T).
+
+sell(Name, Item, Time) ->
+    T = round(Time/5),
+    notify(Name, {Name, sell, T, Item}),
+    timer:sleep(Time).
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_market.erl b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_market.erl
new file mode 100644
index 0000000..241e9cd
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_market.erl
@@ -0,0 +1,77 @@
+%%% Can be used to obtain weapons and pieces of equipment of various types
+%%% to be equipped by the hero. The standard format is:
+%%%  {Name, LevelModifier, Level, Price}.
+-module(pq_market).
+-export([helmet/2, weapon/2, shield/2, armor/2]).
+
+weapon(CombinedLvl, Money) ->
+    L = [
+     {<<"plastic knife">>, -1, 1, 2},
+     {<<"plastic knife">>, 0, 1, 3},
+     {<<"plastic knife">>, 1, 1, 5},
+     {<<"metal spoon">>, -1, 4, 3},
+     {<<"metal spoon">>, 0, 4, 4},
+     {<<"butter knife">>, -1, 6, 5},
+     {<<"butter knife">>, 0, 6, 7},
+     {<<"butter knife">>, 1, 6, 9},
+     {<<"machete">>, -1, 9, 15},
+     {<<"machete">>, 0, 9, 20},
+     {<<"machete">>, 1, 9, 25},
+     {<<"broad sword">>, -1, 12, 23},
+     {<<"broad sword">>, 0, 12, 30},
+     {<<"broad sword">>, 1, 12, 38},
+     {<<"lance">>, -1, 15, 32},
+     {<<"lance">>, 0, 15, 44},
+     {<<"lance">>, 1, 15, 57},
+     {<<"pistol">>, -1, 25, 95},
+     {<<"pistol">>, 0, 25, 105},
+     {<<"pistol">>, 1, 25, 155},
+     {<<"submachine gun">>, -1, 40, 200},
+     {<<"submachine gun">>, 0, 40, 245},
+     {<<"submachine gun">>, 1, 40, 365}
+    ],
+    first_match(fun(W = {_, Modifier, Lvl, Price}) ->
+            if Modifier+Lvl > CombinedLvl, Price =< Money -> W;
+                true -> continue
+            end
+        end, L).
+
+helmet(CombinedLvl, Money) -> pick_material(CombinedLvl, Money).
+shield(CombinedLvl, Money) -> pick_material(CombinedLvl, Money).
+armor(CombinedLvl, Money) -> pick_material(CombinedLvl, Money).
+
+pick_material(CombinedLvl, Money) ->
+    L = materials(),
+    first_match(fun(W = {_, Modifier, Lvl, Price}) ->
+            if Modifier+Lvl > CombinedLvl, Price =< Money -> W;
+                true -> continue
+            end
+        end, L).
+
+
+first_match(_, []) -> undefined;
+first_match(F, [H|T]) ->
+    case F(H) of
+        continue -> first_match(F,T);
+        Val -> Val
+    end.
+
+materials() ->
+    [{<<"wool">>, 0, 1, 25},
+     {<<"pleather">>, 0, 2, 45},
+     {<<"pleather">>, 1, 2, 50},
+     {<<"pleather">>, 2, 2, 65},
+     {<<"leather">>, -2, 7, 30},
+     {<<"leather">>, -1, 7, 35},
+     {<<"leather">>, 0, 7, 45},
+     {<<"leather">>, 2, 7, 65},
+     {<<"chain mail">>, -2, 12, 70},
+     {<<"chain mail">>, 0, 12, 85},
+     {<<"chain mail">>, 1, 12, 95},
+     {<<"chain mail">>, 2, 12, 105},
+     {<<"plate mail">>, -2, 17, 90},
+     {<<"plate mail">>, -1, 17, 95},
+     {<<"plate mail">>, 0, 17, 105},
+     {<<"plate mail">>, 1, 17, 115},
+     {<<"plate mail">>, 2, 17, 135}].
+
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_player.erl b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_player.erl
new file mode 100644
index 0000000..b304f69
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_player.erl
@@ -0,0 +1,175 @@
+%%% The core of ProcessQuest -- the player FSM,
+%%% acting for each of the players in the game.
+%%%
+%%% The FSM actually depends on no external events and only sends messages
+%%% to itself to prompt state changes. This is somewhat unusual as far as
+%%% gen_fsm usages go, but it's pretty useful when needing to work with
+%%% a standalone process.
+-module(pq_player).
+-behaviour(gen_fsm).
+-export([start_link/2]).
+-export([init/1, market/2, killing/2, handle_event/3, handle_sync_event/4,
+         handle_info/3, terminate/3, code_change/4]).
+
+-record(state, {name, stats, exp=0, lvlexp=1000, lvl=1,
+                equip=[], money=0, loot=[], bought=[], time=0}).
+
+
+%%% Possible states & events
+%%
+%      sell  buy
+%     /   | |  \
+%     \   ^ ^  /
+%      [market]<--,
+%      |          |
+% done buying     |
+%      |     bag full
+%      v         /
+%  [killing fields]
+%   /   V   V   |
+%   \   /   |   |
+%   kill    lvl up
+
+start_link(Name, Opts) ->
+    gen_fsm:start_link(?MODULE, {Name, Opts}, []).
+
+init({Name, Opts}) ->
+    %% Properly seeding stuff. If not doing this, the random module will
+    %% seed it based on a slightly unique time value. However, when starting
+    %% many processes at about the same time, the seeds can be very close
+    %% and give barely random results. The crypto:rand_bytes/1 function
+    %% allows for much better seeding.
+    <<A:32, B:32, C:32>> = crypto:rand_bytes(12),
+    random:seed({A,B,C}),
+    %% The first event, to start the FSM
+    gen_fsm:send_event(self(), kill),
+    case regis:register(Name, self()) of
+        {error, _} ->
+            {stop, name_taken};
+        ok ->
+            %% Use proplists with default values to let the user configure
+            %% all parts of the FSM's state by using the Opts proplist.
+            S = #state{
+                name=Name,
+                stats=proplists:get_value(stats, Opts, pq_stats:initial_roll()),
+                exp=proplists:get_value(exp, Opts, 0),
+                lvlexp=proplists:get_value(lvlexp, Opts, 1000),
+                lvl=proplists:get_value(lvl, Opts, 1),
+                equip=proplists:get_value(equip, Opts, []),
+                money=proplists:get_value(money, Opts, 0),
+                loot=proplists:get_value(loot, Opts, []),
+                bought=proplists:get_value(bought, Opts, []),
+                time=proplists:get_value(time, Opts, 0)
+            },
+            {ok, market, S}
+    end.
+
+%% Done selling. Switch to the event where we head to the killing fields
+market(sell, S = #state{loot=[]}) ->
+    gen_fsm:send_event(self(), buy),
+    {next_state, market, S};
+%% Selling an Item we have looted to the market, for whatever value it has
+market(sell, S = #state{loot=[H={_X,Val}|T], money=M}) ->
+    pq_events:sell(S#state.name, H, S#state.time), 
+    gen_fsm:send_event(self(), sell),
+    {next_state, market, S#state{loot=T, money=M+Val}};
+%% When done selling, buy items with your money
+market(buy, S = #state{equip=Equip, money=Money, bought=Bought}) ->
+    %% we have slots of equipment. It's useless to buy the same
+    %% kind of item time after time, so we must select one we haven't observed yet
+    case next_slot(Equip, Bought) of
+        undefined ->
+            %% when no slot is found, go to the killing field
+            gen_fsm:send_event(self(), kill),
+            {next_state, market, S#state{bought=[]}};
+        OldItem = {Slot, {_Name, Modifier, Lvl, _Price}} ->
+            %% Replace the item by a slightly better one if possible.
+            case pq_market:Slot(Modifier+Lvl, Money) of
+                undefined ->
+                    market(buy, S#state{bought=[Slot|Bought]});
+                NewItem = {_, _, _, Price} ->
+                    pq_events:buy(S#state.name, Slot, NewItem, S#state.time),
+                    gen_fsm:send_event(self(), buy),
+                    NewEquip = [{Slot, NewItem} | Equip -- [OldItem]],
+                    {next_state, market, S#state{equip=NewEquip,
+                                                 money=Money-Price,
+                                                 bought=[Slot|Bought]}}
+            end
+    end;
+%% Heading to the killing field. State only useful as a state transition.
+market(kill, S) ->
+    pq_events:location(S#state.name, killing, S#state.time),
+    gen_fsm:send_event(self(), kill),
+    {next_state, killing, S}.
+
+%% Killing an enemy on the killing field. Taking its drop and keeping it
+%% in our loot.
+killing(kill, S = #state{loot=Loot, stats=Stats, exp=Exp, lvlexp=LvlExp}) ->
+    MaxSize = proplists:get_value(strength, Stats)*2,
+    {EnemyName, Props} = pq_enemy:fetch(),
+    pq_events:killed(S#state.name, {EnemyName, Props}, S#state.time),
+    Drop = {_N, _V} = proplists:get_value(drop, Props),
+    KillExp = proplists:get_value(experience, Props),
+    NewLoot = [Drop|Loot],
+    if length(NewLoot) =:= MaxSize ->
+        gen_fsm:send_event(self(), market);
+       Exp+KillExp >= LvlExp ->
+        gen_fsm:send_event(self(), lvl_up);
+       true ->
+        gen_fsm:send_event(self(), kill)
+    end,
+    {next_state, killing, S#state{loot=NewLoot, exp=Exp+KillExp}};
+%% If we just leveled up, the stats get updated before we keep killing.
+killing(lvl_up, S = #state{stats=Stats, lvl=Lvl, lvlexp=LvlExp}) ->
+    NewStats = [{charisma, proplists:get_value(charisma, Stats)+pq_stats:roll()},
+     {constitution, proplists:get_value(constitution, Stats)+pq_stats:roll()},
+     {dexterity, proplists:get_value(dexterity, Stats)+pq_stats:roll()},
+     {intelligence, proplists:get_value(intelligence, Stats)+pq_stats:roll()},
+     {strength, proplists:get_value(strength, Stats)+pq_stats:roll()},
+     {wisdom, proplists:get_value(wisdom, Stats)+pq_stats:roll()}],
+    gen_fsm:send_event(self(), kill),
+    pq_events:lvl_up(S#state.name, NewStats, Lvl+1, LvlExp*2, S#state.time),
+    {next_state, killing, S#state{stats=NewStats, lvl=Lvl+1, lvlexp=LvlExp*2}};
+%% Heading to the market state transition
+killing(market, S) ->
+    pq_events:location(S#state.name, market, S#state.time),
+    gen_fsm:send_event(self(), sell),
+    {next_state, market, S}.
+
+handle_event(_Event, StateName, State) ->
+    {next_state, StateName, State}.
+
+handle_sync_event(_Event, _From, StateName, State) ->
+    {next_state, StateName, State}.
+
+handle_info(_Event, StateName, State) ->
+    {next_state, StateName, State}.
+
+terminate(_Reason, _StateName, _State) ->
+    ok.
+
+code_change(_OldVsn, StateName, State, _Extra) ->
+    {next_state, StateName, State}.
+
+%%%%%%%%%%%%%%%
+%%% PRIVATE %%%
+%%%%%%%%%%%%%%%
+
+%% Picks a slot based on what has been seen so far, combined with the
+%% current weakest item.
+next_slot(Equip, Bought) ->
+    L = expand(Equip),
+    case lists:sort([{Mod+Lvl, Entry} || Entry = {Slot, {_, Mod, Lvl, _}} <- L,
+                                         not lists:member(Slot, Bought)]) of
+        [] -> undefined;
+        [{_, Entry}|_] -> Entry
+    end.
+
+expand(L) ->
+    [expand_field(armor, L),
+     expand_field(helmet, L),
+     expand_field(shield, L),
+     expand_field(weapon, L)].
+
+expand_field(F, L) ->
+    {F, proplists:get_value(F, L, {undefined,0,0,0})}.
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_stats.erl b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_stats.erl
new file mode 100644
index 0000000..379f5e9
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_stats.erl
@@ -0,0 +1,19 @@
+%%% Rolls dice to generate statistics or level increases for a character
+-module(pq_stats).
+-export([initial_roll/0, roll/0]).
+
+%% First roll, when setting the stats up for the first time
+initial_roll() ->
+    [{charisma, roll(3)},
+     {constitution, roll(3)},
+     {dexterity, roll(3)},
+     {intelligence, roll(3)},
+     {strength, roll(3)},
+     {wisdom, roll(3)}].
+
+%% Rolls a single die. Used when leveling up
+roll() -> roll(1).
+
+%% Rolls Num 6-faced dice
+roll(Num) ->
+    lists:sum([random:uniform(6) || _ <- lists:seq(1,Num)]).
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_sup.erl b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_sup.erl
new file mode 100644
index 0000000..de89a9a
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_sup.erl
@@ -0,0 +1,31 @@
+%%% Supervisor for each player. Goes over a pair of a
+%%% gen_fsm (pq_player) and gen_event (pq_events).
+-module(pq_sup).
+-behaviour(supervisor).
+-export([start_link/2]).
+-export([init/1]).
+
+
+start_link(Name, Info) ->
+    supervisor:start_link(?MODULE, {Name,Info}).
+
+%% The name is passed to the events so that
+%% it can register itself as {events, Name} into the
+%% 'regis' regsitry app.
+%% Same for pq_player, which also gets the info.
+%%
+%% It is important that pq_events is started before
+%% pq_player, otherwise we might create race conditions
+%% when starting a player and then quickly generating events to
+%% an event manager that doesn't exist.
+init({Name, Info}) ->
+    {ok,
+     {{one_for_all, 2, 3600},
+      [{events,
+        {pq_events, start_link, [Name]},
+        permanent, 5000, worker, [dynamic]},
+       {player,
+        {pq_player, start_link, [Name, Info]},
+        permanent, 2000, worker, [pq_player]}]}}.
+
+
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_supersup.erl b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_supersup.erl
new file mode 100644
index 0000000..577bbed
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/pq_supersup.erl
@@ -0,0 +1,28 @@
+%%% pq_supersup is the ProcessQuest top-level supervisor.
+%%% It sits over many pq_sup instances, allowing to have
+%%% a truckload of different players running at once.
+-module(pq_supersup).
+-behaviour(supervisor).
+-export([start_link/0, start_player/2, stop_player/1]).
+-export([init/1]).
+
+%% We register it so that it's guaranteed to be unique
+start_link() ->
+    supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
+%% Using a SOFO strategy because we get to have many
+%% supervisees of the same type.
+init([]) ->
+    {ok,
+     {{simple_one_for_one, 1, 60000},
+      [{sup,
+        {pq_sup, start_link, []},
+        permanent, infinity, supervisor, [pq_sup]}]}}.
+
+%% Starts an individual player
+start_player(Name, Info) ->
+    supervisor:start_child(?MODULE, [Name, Info]).
+
+%% Stops a player.
+stop_player(Name) ->
+    supervisor:terminate_child(?MODULE, regis:whereis(Name)).
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/processquest.erl b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/processquest.erl
new file mode 100644
index 0000000..469dcb0
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/src/processquest.erl
@@ -0,0 +1,39 @@
+%%% ProcessQuest's main wrapping module.
+%%% Start ProcessQuest by calling application:start(processquest).
+%%% Create a player by calling processquest:start_player(Name, Info).
+%%% - Name is any term to identify the player
+%%% - Info is additional information to configure the player. Consult
+%%%   the pq_player module for more info.
+%%%
+%%% You can subscribe to the player events by calling
+%%% processquest:subscribe(Name, Handler, Args).
+%%% The handler is a regular event handler. See test/pq_events_handler.erl.
+-module(processquest).
+-behaviour(application).
+-export([start/2, stop/1]).
+-export([start_player/2, stop_player/1, subscribe/3]).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% APPLICATION CALLBACKS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+start(normal, []) ->
+    pq_supersup:start_link().
+
+stop(_) -> ok.
+
+%%%%%%%%%%%%%%%%%%%%%%
+%%% USER INTERFACE %%%
+%%%%%%%%%%%%%%%%%%%%%%
+
+%% Starts a player
+start_player(Name, Info) ->
+    pq_supersup:start_player(Name, Info). 
+
+%% Stops a player
+stop_player(Name) ->
+    pq_supersup:stop_player(Name).
+
+%% Subscribe to user events
+subscribe(Name, Handler, Args) ->
+    pq_events:add_handler(Name, Handler, Args).
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_enemy_tests.erl b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_enemy_tests.erl
new file mode 100644
index 0000000..14742fa
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_enemy_tests.erl
@@ -0,0 +1,33 @@
+-module(pq_enemy_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+is_random_test_() ->
+    F = fun(Parent, Ref) -> fun() ->
+        <<A:32,B:32,C:32>> = crypto:rand_bytes(12),
+        random:seed({A,B,C}),
+        Entries = [pq_enemy:fetch() || _ <- lists:seq(1,100)],
+        Parent ! {Ref, Entries}
+    end end,
+    Refs = [begin
+                Ref = make_ref(),
+                spawn_link(F(self(), Ref)),
+                Ref
+            end || _ <- lists:seq(1,3)],
+    [A,B,C] = [receive
+                {Ref, X} -> X
+               end || Ref <- Refs],
+    [?_assert(A =/= B),
+     ?_assert(A =/= C),
+     ?_assert(B =/= C)].
+
+format_test_() ->
+    [[?_assertMatch({_Name, [{drop, {_DropName, _DropVal}},
+                             {experience, _Exp}]}, pq_enemy:fetch())
+        || _ <- lists:seq(1,10)],
+     begin
+        {Name, [{drop, {Drop, Val}}, {experience, Exp}]} = pq_enemy:fetch(),
+        [?_assert(is_binary(Name)),
+         ?_assert(is_binary(Drop)),
+         ?_assert(is_integer(Val)),
+         ?_assert(is_integer(Exp))]
+     end].
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_events_handler.erl b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_events_handler.erl
new file mode 100644
index 0000000..a02df4c
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_events_handler.erl
@@ -0,0 +1,24 @@
+%% A fake event handler used for tests
+-module(pq_events_handler).
+-behaviour(gen_event).
+-export([init/1, handle_event/2, handle_call/2, handle_info/2,
+         terminate/2, code_change/3]).
+
+init(Parent) -> {ok, Parent}.
+
+handle_event(E, Pid) ->
+    Pid ! E,
+    {ok, Pid}.
+
+handle_call(Req, Pid) ->
+    Pid ! Req,
+    {ok, ok, Pid}.
+
+handle_info(E, Pid) ->
+    Pid ! E,
+    {ok, Pid}.
+
+terminate(_, _) -> ok.
+
+code_change(_OldVsn, Pid, _Extra) ->
+    {ok, Pid}.
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_events_tests.erl b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_events_tests.erl
new file mode 100644
index 0000000..3a327b7
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_events_tests.erl
@@ -0,0 +1,55 @@
+-module(pq_events_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+-define(setup(Name, T), {setup, fun() -> start(Name) end, fun stop/1, fun T/1}).
+-define(setup(T), ?setup(make_ref(), T)).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% TESTS DESCRIPTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%
+events_start_stop_reg_test_() ->
+    {"The event handler can be reached, started and stopped by using the "
+     "player's name",
+      ?setup(can_contact)}.
+
+%%%%%%%%%%%%%%%%%%%%%%%
+%%% SETUP FUNCTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%
+start(Name) ->
+    application:start(regis),
+    {ok, Pid} = pq_events:start_link(Name),
+    unlink(Pid),
+    Name.
+
+stop(Name) ->
+    pq_events:stop(Name).
+
+%%%%%%%%%%%%%%%%%%%%
+%%% ACTUAL TESTS %%%
+%%%%%%%%%%%%%%%%%%%%
+can_contact(Name) ->
+    ok = pq_events:add_handler(Name, pq_events_handler, self()),
+    pq_events:notify(Name, hello),
+    L1 = flush(),
+    pq_events:delete_handler(Name, pq_events_handler, []),
+    pq_events:notify(Name, hello),
+    L2 = flush(),
+    [?_assertEqual([hello], L1),
+     ?_assertEqual([], L2)].
+    
+%%%%%%%%%%%%%%%%%%%%%%%%
+%%% HELPER FUNCTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%
+flush() ->
+    receive
+        X -> [X | flush1()]
+    after 300 ->
+        []
+    end.
+
+flush1() ->
+    receive
+        X -> [X | flush1()]
+    after 0 ->
+        []
+    end.
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_market_tests.erl b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_market_tests.erl
new file mode 100644
index 0000000..d689f67
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_market_tests.erl
@@ -0,0 +1,15 @@
+-module(pq_market_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+best_smallest_weapon_test_() ->
+    [?_assertMatch({<<"plastic knife">>, 0, 1, 3}, pq_market:weapon(0, 5)),
+     ?_assertMatch({<<"plastic knife">>, 1, 1, 5}, pq_market:weapon(1, 100)),
+     ?_assertMatch(undefined, pq_market:weapon(0,0)),
+     ?_assertMatch(undefined, pq_market:weapon(50000,100000000000000000000))].
+
+best_smallest_gear_test_() ->
+    [[?_assertMatch({<<"wool">>, 0, 1, 25}, pq_market:F(0, 35)),
+      ?_assertMatch({<<"pleather">>, 0, 2, 45}, pq_market:F(1, 100)),
+      ?_assertMatch(undefined, pq_market:F(0,0)),
+      ?_assertMatch(undefined, pq_market:F(50000,100000000000000000000))]
+        || F <- [helmet, shield, armor]].
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_player_tests.erl b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_player_tests.erl
new file mode 100644
index 0000000..bbdbf3d
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_player_tests.erl
@@ -0,0 +1,303 @@
+-module(pq_player_tests).
+-include_lib("eunit/include/eunit.hrl").
+-record(state, {name, stats, exp=0, lvlexp=1000, lvl=1, % copied from pq_player.erl
+                 equip=[], money=0, loot=[], bought=[], time=0}).
+
+-define(setup(Name, T), {setup, fun() -> start(Name) end, fun stop/1, fun T/1}).
+-define(setup(T), ?setup(make_ref(), T)).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% TESTS DESCRIPTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%
+new_player_test_() ->
+    [{"A player holds its own name in its state",
+      ?setup(initial_name)},
+     {"A new player has stats randomly rolled",
+      ?setup(initial_roll)},
+     {"A new player becomes a registered process",
+      ?setup(initial_register)},
+     {"A player has a counter for experience and a counter for "
+      "the next level (which is higher than the current exp)",
+      ?setup(initial_lvl)},
+     {"A player has a basic equipment (empty) when first going",
+      ?setup(initial_equipment)},
+     {"A new player has no money",
+      ?setup(initial_money)},
+     {"A new player has no loot",
+      ?setup(initial_loot)},
+     {"The state of a player can be overriden using the info "
+      "arguments to the init function",
+      ?setup(override_init)}].
+
+market_test_() ->
+    [{"A player with N items will sell all of them to the market "
+      "and end with equivalent money, before switching to the "
+      "buying state",
+      ?setup(sell_all)},
+     {"A player with nearly infinite money will buy items available "
+      "for his money, higher than his level",
+      ?setup(buy_items)},
+     {"A player with no money or no items available for the price "
+      "range leaves for the killing fields.",
+      ?setup(buy_none)},
+     {"Receiving the kill message just forwards to the killing state",
+      ?setup(to_killing)}].
+
+killing_fields_test_() ->
+    [{"Kill enemies until the loot limit is hit. Loot is 2x Strength",
+      ?setup(loot_limit)},
+     {"Killing enemies raises XP until someone levels up",
+      ?setup(kill_xp)},
+     {"Leveling up boosts stats. The sum is higher by at least as "
+      "many points as there are fields, but not more than 6 times. "
+      "Moreover, the rolling is random.",
+      ?setup(lvl_stats)},
+     {"receiving the market message just forwards to the market state",
+      ?setup(to_market)}].
+
+%%%%%%%%%%%%%%%%%%%%%%%
+%%% SETUP FUNCTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%
+start(Name) ->
+    application:start(crypto),
+    application:start(regis),
+    Pid = spawn(fun() -> timer:sleep(infinity) end),
+    regis:register({events, Name}, Pid),
+    Name.
+
+stop(Name) ->
+    exit(regis:whereis({events, Name}), kill),
+    application:stop(regis),
+    application:stop(crypto).
+
+%%%%%%%%%%%%%%%%%%%%
+%%% ACTUAL TESTS %%%
+%%%%%%%%%%%%%%%%%%%%
+
+%% Initial State
+initial_name(Name) ->
+    {ok, market, S} = pq_player:init({Name, []}),
+    M = read_event(),
+    [?_assertEqual(Name, S#state.name),
+     ?_assertEqual(M, kill)].
+
+initial_roll(Name) ->
+    {ok, _, S} = pq_player:init({Name, []}),
+    _ = read_event(),
+    ?_assertMatch([{charisma,_}, {constitution, _}, {dexterity, _},
+                   {intelligence, _}, {strength, _}, {wisdom, _}],
+                  lists:sort(S#state.stats)).
+
+initial_register(Ref) ->
+    {ok, _, _} = pq_player:init({Ref, []}),
+    _ = read_event(),
+    Pid = regis:whereis(Ref),
+    Ret = pq_player:init({Ref, []}),
+    _ = read_event(),
+    [?_assert(undefined =/= Pid),
+     ?_assert(is_pid(Pid)),
+     ?_assertEqual({stop, name_taken}, Ret)].
+
+initial_lvl(Name) ->
+    {ok, _, S} = pq_player:init({Name, []}),
+    _ = read_event(),
+    [?_assert(is_integer(S#state.lvlexp)),
+     ?_assert(S#state.lvlexp > 0),
+     ?_assert(S#state.exp =:= 0)]. % start at 0 exp
+
+initial_equipment(Name) ->
+    {ok, _, S} = pq_player:init({Name, []}),
+    _ = read_event(),
+    [?_assert(is_list(S#state.equip)),
+     ?_assertEqual(undefined, proplists:get_value(armor, S#state.equip)),
+     ?_assertEqual(undefined, proplists:get_value(helmet, S#state.equip)),
+     ?_assertEqual(undefined, proplists:get_value(weapon, S#state.equip)),
+     ?_assertEqual(undefined, proplists:get_value(shield, S#state.equip))].
+
+initial_money(Name) ->
+    {ok, _, S} = pq_player:init({Name, []}),
+    _ = read_event(),
+    ?_assertEqual(0, S#state.money).
+
+initial_loot(Name) ->
+    {ok, _, S} = pq_player:init({Name, []}),
+    _ = read_event(),
+    ?_assertEqual([], S#state.loot).
+
+override_init(Name) ->
+    {ok, _, Partial} = pq_player:init({Name, [
+        {stats, [{charisma,1}, {constitution,1}, {dexterity,1},
+                 {intelligence,1}, {strength,1}, {wisdom,1}]},
+        {lvlexp,1}]}),
+    regis:unregister(Name),
+    _ = read_event(),
+    {ok, _, Complete} = pq_player:init({Name, [
+        {stats, [{charisma,1}, {constitution,1}, {dexterity,1},
+                 {intelligence,1}, {strength,1}, {wisdom,1}]},
+        {exp, 1}, {lvlexp,1}, {lvl,9},
+        {equip, [{weapon,{<<"plastic knife">>, -1, 1, 2}}]},
+        {money,1}, {loot, [{<<"Bacon">>, 1}]}, {bought, [helmet]}
+    ]}),
+    _ = read_event(),
+    [?_assertMatch(#state{stats=[{_,1},{_,1},{_,1},{_,1},{_,1},{_,1}],
+                          lvlexp=1, lvl=1, exp=0},
+                   Partial),
+     ?_assertMatch(#state{stats=[{_,1},{_,1},{_,1},{_,1},{_,1},{_,1}],
+                          exp=1, lvlexp=1, lvl=9, equip=[{weapon,_}],
+                          money=1, loot=[{_,_}], bought=[_]},
+                   Complete)].
+
+%% Market
+sell_all(Name) ->
+    undefined = read_event(),
+    Loot = [proplists:get_value(drop, element(2, pq_enemy:fetch()))
+             || _ <- lists:seq(1,5)],
+    {[Sum1, Sum2, Sum3, Sum4, Sum5], _} = lists:mapfoldl(
+        fun(X, Sum) -> {X+Sum, X+Sum} end,
+        0,
+        [Val || {_, Val} <- Loot]
+    ),
+    %undefined = read_event(),
+    S0 = #state{name=Name, loot=Loot, money=0, lvl=1},
+    {next_state, market, S1} = pq_player:market(sell, S0),
+    M1 = read_event(),
+    {next_state, market, S2} = pq_player:market(sell, S1),
+    M2 = read_event(),
+    {next_state, market, S3} = pq_player:market(sell, S2),
+    M3 = read_event(),
+    {next_state, market, S4} = pq_player:market(sell, S3),
+    M4 = read_event(),
+    {next_state, market, S5} = pq_player:market(sell, S4),
+    M5 = read_event(),
+    {next_state, market, S6} = pq_player:market(sell, S5),
+    M6 = read_event(),
+    [?_assertMatch(#state{money=Sum1, loot=[_,_,_,_]}, S1),
+     ?_assertMatch(#state{money=Sum2, loot=[_,_,_]}, S2),
+     ?_assertMatch(#state{money=Sum3, loot=[_,_]}, S3),
+     ?_assertMatch(#state{money=Sum4, loot=[_]}, S4),
+     ?_assertMatch(#state{money=Sum5, loot=[]}, S5),
+     ?_assertMatch(#state{money=Sum5, loot=[]}, S6),
+     ?_assertEqual([sell, sell, sell, sell, sell, buy],
+                   [M1,M2,M3,M4,M5,M6])].
+
+buy_items(Name) ->
+    %% 4 different pieces of equipment to buy
+    S0 = #state{name=Name, equip=[], money=999999999999},
+    {next_state, market, S1} = pq_player:market(buy, S0),
+    M1 = read_event(),
+    {next_state, market, S2} = pq_player:market(buy, S1),
+    M2 = read_event(),
+    {next_state, market, S3} = pq_player:market(buy, S2),
+    M3 = read_event(),
+    {next_state, market, S4} = pq_player:market(buy, S3),
+    M4 = read_event(),
+    %% All slots bought. Implicit requirement: not buying for the
+    %% same slot twice.
+    {next_state, market, S5} = pq_player:market(buy, S4),
+    M5 = read_event(),
+    [?_assertEqual([S5#state.money, S4#state.money, S3#state.money,
+                    S2#state.money, S1#state.money, S0#state.money],
+                   lists:sort([S5#state.money, S4#state.money, S3#state.money,
+                          S2#state.money, S1#state.money, S0#state.money])),
+     ?_assertEqual([1,2,3,4,4],
+                   [length(L) || L <- [S1#state.equip, S2#state.equip,
+                                       S3#state.equip, S4#state.equip,
+                                       S5#state.equip]]),
+     ?_assertEqual([buy, buy, buy, buy, kill],
+                   [M1, M2, M3, M4, M5])]. 
+
+buy_none(Name) ->
+    S0 = #state{name=Name, equip=[], money=0},
+    %% one try per part of the equipment
+    {next_state, market, S1} = pq_player:market(buy, S0),
+    _ = read_event(),
+    {next_state, market, S2} = pq_player:market(buy, S1),
+    _ = read_event(),
+    {next_state, market, S3} = pq_player:market(buy, S2),
+    _ = read_event(),
+    {next_state, market, S4} = pq_player:market(buy, S3),
+    M = read_event(),
+    [?_assertEqual(S0, S4),
+     ?_assertEqual(kill, M)].
+
+to_killing(Name) ->
+    S = #state{name=Name},
+    Res = pq_player:market(kill, S),
+    M = read_event(),
+    [?_assertMatch({next_state, killing, S}, Res),
+     ?_assertEqual(kill, M)].
+
+%% Killing fields tests
+loot_limit(Name) ->
+    S0 = #state{name=Name, stats=[{strength, 2}], loot=[]},
+    {next_state, killing, S1 = #state{loot=L1}} = pq_player:killing(kill, S0),
+    M1 = read_event(),
+    {next_state, killing, S2 = #state{loot=L2}} = pq_player:killing(kill, S1),
+    M2 = read_event(),
+    {next_state, killing, S3 = #state{loot=L3}} = pq_player:killing(kill, S2),
+    M3 = read_event(),
+    {next_state, killing, #state{loot=L4}} = pq_player:killing(kill, S3),
+    M4 = read_event(),
+    %% Group identical drops with a counter?
+    [?_assertEqual([1,2,3,4], [length(L) || L <- [L1, L2, L3, L4]]),
+     ?_assertEqual([kill, kill, kill, market], [M1, M2, M3, M4])].
+
+kill_xp(Name) ->
+    S0 = #state{name=Name, stats=[{strength, 999}|pq_stats:initial_roll()],
+                lvl=1, exp=0, lvlexp=5},
+    %% between 1 and 5 kills required to lvl up.
+    {next_state, NS1, S1} = pq_player:killing(kill, S0),
+    M1 = read_event(),
+    {next_state, NS2, S2} = pq_player:NS1(M1, S1),
+    M2 = read_event(),
+    {next_state, NS3, S3} = pq_player:NS2(M2, S2),
+    M3 = read_event(),
+    {next_state, NS4, S4} = pq_player:NS3(M3, S3),
+    M4 = read_event(),
+    {next_state, NS5, S5} = pq_player:NS4(M4, S4),
+    M5 = read_event(),
+    {next_state, NS6, S6} = pq_player:NS5(M5, S5),
+    M6 = read_event(),
+    [?_assert(lists:any(fun(#state{lvl=L}) -> L > 1 end, [S1,S2,S3,S4,S5,S6])),
+     ?_assert(lists:any(fun(#state{lvlexp=L}) -> L >= 10 end, [S1,S2,S3,S4,S5,S6])),
+     ?_assert(lists:any(fun(#state{exp=E}) -> E >= 5 end, [S1,S2,S3,S4,S5,S6])),
+     ?_assert(lists:any(fun(FSMState) -> FSMState =:= killing end,
+                        [NS1, NS2, NS3, NS4, NS5, NS6])),
+     ?_assert(lists:any(fun(Msg) -> Msg =:= kill end,
+                        [M1, M2, M3, M4, M5, M6])),
+     ?_assert(lists:any(fun(Msg) -> Msg =:= lvl_up end,
+                        [M1, M2, M3, M4, M5, M6]))].
+
+lvl_stats(Name) ->
+    {ok, _, S0} = pq_player:init({Name, []}),
+    _ = read_event(),
+    TotalStats = length(S0#state.stats),
+    {next_state, killing, S1} = pq_player:killing(lvl_up, S0),
+    _ = read_event(),
+    {next_state, killing, S2} = pq_player:killing(lvl_up, S0),
+    _ = read_event(),
+    SumInit = lists:sum([Pts || {_,Pts} <- S0#state.stats]),
+    SumS1 = lists:sum([Pts || {_,Pts} <- S1#state.stats]),
+    SumS2 = lists:sum([Pts || {_,Pts} <- S2#state.stats]),
+    [?_assert(SumS1 >= TotalStats+SumInit),
+     ?_assert(SumS2 >= TotalStats+SumInit),
+     ?_assert(SumS1 =< TotalStats*6 + SumInit),
+     ?_assert(SumS2 =< TotalStats*6 + SumInit),
+     ?_assert(S1#state.stats =/= S2#state.stats)].
+
+to_market(Name) ->
+    S = #state{name=Name},
+    Res = pq_player:killing(market, S),
+    M = read_event(),
+    [?_assertMatch({next_state, market, S}, Res),
+     ?_assertEqual(sell, M)].
+
+%%%%%%%%%%%%%%%%%%%%%%%%
+%%% HELPER FUNCTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%
+read_event() ->
+    receive
+        {'$gen_event', Msg} -> Msg
+    after 0 ->
+        undefined
+    end.
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_stats_tests.erl b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_stats_tests.erl
new file mode 100644
index 0000000..da9daa5
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/pq_stats_tests.erl
@@ -0,0 +1,28 @@
+-module(pq_stats_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+all_stats_test_() ->
+    Stats = pq_stats:initial_roll(),
+    {"Checks whether all stats are returned",
+     [?_assertEqual([charisma, constitution, dexterity,
+                     intelligence, strength, wisdom],
+                    lists:sort(proplists:get_keys(Stats)))]}.
+
+initial_roll_test_() ->
+    Rolls = [pq_stats:initial_roll() || _ <- lists:seq(1,100)],
+    {"All die rolls are made out of 3 d6 dice",
+     %% 6 == number of stats
+     [?_assertEqual(6, length([S || {_,S} <- Stats, S >= 3, S =< 18]))
+        || Stats <- Rolls]}.
+
+initial_random_roll_test_() ->
+    Stats = [pq_stats:initial_roll() || _ <- lists:seq(1,100)],
+    {"All die rolls are random",
+     ?_assertEqual(lists:sort(Stats),
+                   lists:sort(sets:to_list(sets:from_list(Stats))))}.
+
+single_die_roll_test_() ->
+    Rolls = [pq_stats:roll() || _ <- lists:seq(1,100)],
+    [?_assertEqual(100, length([N || N <- Rolls, N >= 1, N =< 6])),
+     ?_assert(1 =/= length(sets:to_list(sets:from_list(Rolls))))].
+
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/processquest_tests.erl b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/processquest_tests.erl
new file mode 100644
index 0000000..fa118b1
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.0.0/test/processquest_tests.erl
@@ -0,0 +1,49 @@
+-module(processquest_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+%%% Integration tests verifying the whole app.
+-define(setup(Name, T), {setup, fun() -> start(Name) end, fun stop/1, fun T/1}).
+-define(setup(T), ?setup(make_ref(), T)).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% TESTS DESCRIPTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%
+integration_test_() ->
+    [{"A player can be started from the processquest module and monitored",
+     ?setup(subscribe)}].
+
+%%%%%%%%%%%%%%%%%%%%%%%
+%%% SETUP FUNCTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%
+start(Name) ->
+    application:start(crypto),
+    application:start(regis),
+    application:start(processquest),
+    processquest:start_player(Name, [{time,1100}]),
+    Name.
+
+stop(Name) ->
+    processquest:stop_player(Name),
+    application:stop(processquest),
+    application:stop(regis).
+
+%%%%%%%%%%%%%%%%%%%%
+%%% ACTUAL TESTS %%%
+%%%%%%%%%%%%%%%%%%%%
+subscribe(Name) ->
+    ok = processquest:subscribe(Name, pq_events_handler, self()),
+    timer:sleep(4000),
+    Msgs = flush(),
+    [?_assertMatch([{Name, killed, _Time1, {_EnemyName1, _Props1}},
+                    {Name, killed, _Time2, {_EnemyName2, _Props2}},
+                    {Name, killed, _Time3, {_EnemyName3, _Props3}}],
+                   Msgs)].
+
+%%%%%%%%%%%%%%%%%%%%%%%%
+%%% HELPER FUNCTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%
+flush() ->
+    receive
+        X -> [X | flush()]
+    after 0 -> []
+    end.
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/Emakefile b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/Emakefile
new file mode 100644
index 0000000..b203ea3
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/Emakefile
@@ -0,0 +1,2 @@
+{["src/*", "test/*"],
+ [{i,"include"}, {outdir, "ebin"}]}.
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/ebin/.this-file-intentionally-left-blank b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/ebin/.this-file-intentionally-left-blank
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/ebin/.this-file-intentionally-left-blank
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/ebin/processquest.app b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/ebin/processquest.app
new file mode 100644
index 0000000..d923479
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/ebin/processquest.app
@@ -0,0 +1,8 @@
+{application, processquest,
+ [{description, "Game inspired by the Progress Quest game (http://progressquest.com)"},
+  {vsn, "1.1.0"},
+  {mod, {processquest, []}},
+  {registered, [pq_supersup]},
+  {modules, [processquest, pq_stats, pq_enemy, pq_quest, pq_events,
+             pq_player]},
+  {applications, [stdlib, kernel, regis, crypto]}]}.
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/ebin/processquest.appup b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/ebin/processquest.appup
new file mode 100644
index 0000000..41d305c
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/ebin/processquest.appup
@@ -0,0 +1,9 @@
+{"1.1.0",
+ [{"1.0.0", [{add_module, pq_quest},
+             {load_module, pq_enemy},
+             {load_module, pq_events},
+             {update, pq_player, {advanced, []}, [pq_quest, pq_events]}]}],
+ [{"1.0.0", [{update, pq_player, {advanced, []}},
+             {delete_module, pq_quest},
+             {load_module, pq_enemy},
+             {load_module, pq_events}]}]}.
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/include/.this-file-intentionally-left-blank b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/include/.this-file-intentionally-left-blank
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/include/.this-file-intentionally-left-blank
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/priv/.this-file-intentionally-left-blank b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/priv/.this-file-intentionally-left-blank
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/priv/.this-file-intentionally-left-blank
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_enemy.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_enemy.erl
new file mode 100644
index 0000000..e1c2332
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_enemy.erl
@@ -0,0 +1,32 @@
+%% Gives random enemies
+-module(pq_enemy).
+-export([fetch/0]).
+
+fetch() ->
+    L = enemies(),
+    lists:nth(random:uniform(length(L)), L).
+
+enemies() ->
+    [{<<"Spider">>, [{drop, {<<"Spider Egg">>, 1}}, {experience, 1}]},
+     {<<"Wildcat">>, [{drop, {<<"Pelt">>, 1}}, {experience, 1}]},
+     {<<"Pig">>, [{drop, {<<"Bacon">>, 1}}, {experience, 1}]},
+     {<<"Wild Pig">>, [{drop, {<<"Tasty Ribs">>, 2}}, {experience, 1}]},
+     {<<"Goblin">>, [{drop, {<<"Goblin hair">>, 1}}, {experience, 2}]},
+     {<<"Robot">>, [{drop, {<<"Chunks of Metal">>, 3}}, {experience, 2}]},
+     {<<"Factory Worker">>, [{drop, {<<"Wrench">>,2}}, {experience,1}]},
+     {<<"Carnie">>, [{drop, {<<"Cotton Candy">>,1}}, {experience,1}]},
+     {<<"Mad Beaver">>, [{drop, {<<"Wood chips">>, 2}}, {experience, 1}]},
+     {<<"Silent magpie">>, [{drop, {<<"Shiny things">>, 3}}, {experience, 1}]},
+     {<<"Great Lizard">>, [{drop, {<<"Lizard tail">>, 1}}, {experience, 1}]},
+     {<<"Cheetah">>, [{drop, {<<"Fur">>, 3}}, {experience, 4}]},
+     {<<"Radish Horse">>, [{drop, {<<"Horseradish">>,1}}, {experience, 2}]},
+     {<<"Sand Worm">>, [{drop, {<<"Spices">>,10}}, {experience, 25}]},
+     {<<"Mule">>, [{drop, {<<"Map">>, 2}}, {experience, 12}]},
+     {<<"Man Tree">>, [{drop, {<<"branch">>,1}}, {experience, 2}]},
+     {<<"Penguin Lord">>, [{drop, {<<"Penguin Egg">>,1}}, {experience, 3}]},
+     {<<"Cursed Priest">>, [{drop, {<<"Grail">>, 3}}, {experience, 5}]},
+     {<<"Bearded cow">>, [{drop, {<<"Hairy milk">>, 1}}, {experience, 6}]},
+     {<<"Hellish crow">>, [{drop, {<<"Black feather">>, 1}}, {experience, 1}]},
+     {<<"Wolverine">>, [{drop, {<<"Puddle of blood">>, 1}}, {experience, 2}]},
+     {<<"Gangsta Bear">>, [{drop, {<<"Bear Grylls">>, 3}}, {experience, 4}]}].
+
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_events.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_events.erl
new file mode 100644
index 0000000..faea13e
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_events.erl
@@ -0,0 +1,53 @@
+%%% Wrapper module for the event manager of ProgressQuest players.
+%%% It adds a few functions to wrap the events and sleep on the right
+%%% scale on behalf of the pq_player process.
+-module(pq_events).
+-export([killed/3, location/3, lvl_up/5, buy/4, sell/3, quest/4]).
+-export([start_link/1, stop/1, add_handler/3, delete_handler/3, notify/2]).
+
+start_link(Name) ->
+    {ok, Pid} = gen_event:start_link(),
+    ok = regis:register({events, Name}, Pid),
+    {ok, Pid}.
+
+stop(Name) ->
+    ManagerPid = regis:whereis({events, Name}),
+    gen_event:stop(ManagerPid).
+
+add_handler(Name, Handler, Args) ->
+    ManagerPid = regis:whereis({events, Name}),
+    gen_event:add_handler(ManagerPid, Handler, Args).
+
+delete_handler(Name, Handler, Args) ->  
+    ManagerPid = regis:whereis({events, Name}),
+    gen_event:delete_handler(ManagerPid, Handler, Args).
+
+notify(Name, Msg) ->
+    ManagerPid = regis:whereis({events, Name}),
+    gen_event:notify(ManagerPid, Msg).
+
+killed(Name, Enemy = {_EnemyName, _Props}, Time) ->
+    notify(Name, {Name, killed, Time*2, Enemy}),
+    timer:sleep(Time*2).
+    
+location(Name, Place, Time) ->
+    notify(Name, {Name, heading, Time, Place}), 
+    timer:sleep(Time).
+
+lvl_up(Name, NewStats, NewLvl, NewExp, _Time) ->
+    notify(Name, {Name, lvl_up, 0, NewStats, NewLvl, NewExp}),
+    ok.
+
+buy(Name, Slot, Item, Time) ->
+    T = round(Time/2),
+    notify(Name, {Name, buy, T, Slot, Item}),
+    timer:sleep(T).
+
+sell(Name, Item, Time) ->
+    T = round(Time/5),
+    notify(Name, {Name, sell, T, Item}),
+    timer:sleep(Time).
+
+quest(Name, {Old, _}, {New, _}, _Time) ->
+    notify(Name, {Name, quest, 0, Old, New}),
+    ok.
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_market.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_market.erl
new file mode 100644
index 0000000..241e9cd
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_market.erl
@@ -0,0 +1,77 @@
+%%% Can be used to obtain weapons and pieces of equipment of various types
+%%% to be equipped by the hero. The standard format is:
+%%%  {Name, LevelModifier, Level, Price}.
+-module(pq_market).
+-export([helmet/2, weapon/2, shield/2, armor/2]).
+
+weapon(CombinedLvl, Money) ->
+    L = [
+     {<<"plastic knife">>, -1, 1, 2},
+     {<<"plastic knife">>, 0, 1, 3},
+     {<<"plastic knife">>, 1, 1, 5},
+     {<<"metal spoon">>, -1, 4, 3},
+     {<<"metal spoon">>, 0, 4, 4},
+     {<<"butter knife">>, -1, 6, 5},
+     {<<"butter knife">>, 0, 6, 7},
+     {<<"butter knife">>, 1, 6, 9},
+     {<<"machete">>, -1, 9, 15},
+     {<<"machete">>, 0, 9, 20},
+     {<<"machete">>, 1, 9, 25},
+     {<<"broad sword">>, -1, 12, 23},
+     {<<"broad sword">>, 0, 12, 30},
+     {<<"broad sword">>, 1, 12, 38},
+     {<<"lance">>, -1, 15, 32},
+     {<<"lance">>, 0, 15, 44},
+     {<<"lance">>, 1, 15, 57},
+     {<<"pistol">>, -1, 25, 95},
+     {<<"pistol">>, 0, 25, 105},
+     {<<"pistol">>, 1, 25, 155},
+     {<<"submachine gun">>, -1, 40, 200},
+     {<<"submachine gun">>, 0, 40, 245},
+     {<<"submachine gun">>, 1, 40, 365}
+    ],
+    first_match(fun(W = {_, Modifier, Lvl, Price}) ->
+            if Modifier+Lvl > CombinedLvl, Price =< Money -> W;
+                true -> continue
+            end
+        end, L).
+
+helmet(CombinedLvl, Money) -> pick_material(CombinedLvl, Money).
+shield(CombinedLvl, Money) -> pick_material(CombinedLvl, Money).
+armor(CombinedLvl, Money) -> pick_material(CombinedLvl, Money).
+
+pick_material(CombinedLvl, Money) ->
+    L = materials(),
+    first_match(fun(W = {_, Modifier, Lvl, Price}) ->
+            if Modifier+Lvl > CombinedLvl, Price =< Money -> W;
+                true -> continue
+            end
+        end, L).
+
+
+first_match(_, []) -> undefined;
+first_match(F, [H|T]) ->
+    case F(H) of
+        continue -> first_match(F,T);
+        Val -> Val
+    end.
+
+materials() ->
+    [{<<"wool">>, 0, 1, 25},
+     {<<"pleather">>, 0, 2, 45},
+     {<<"pleather">>, 1, 2, 50},
+     {<<"pleather">>, 2, 2, 65},
+     {<<"leather">>, -2, 7, 30},
+     {<<"leather">>, -1, 7, 35},
+     {<<"leather">>, 0, 7, 45},
+     {<<"leather">>, 2, 7, 65},
+     {<<"chain mail">>, -2, 12, 70},
+     {<<"chain mail">>, 0, 12, 85},
+     {<<"chain mail">>, 1, 12, 95},
+     {<<"chain mail">>, 2, 12, 105},
+     {<<"plate mail">>, -2, 17, 90},
+     {<<"plate mail">>, -1, 17, 95},
+     {<<"plate mail">>, 0, 17, 105},
+     {<<"plate mail">>, 1, 17, 115},
+     {<<"plate mail">>, 2, 17, 135}].
+
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_player.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_player.erl
new file mode 100644
index 0000000..9cca7e0
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_player.erl
@@ -0,0 +1,216 @@
+%%% The core of ProcessQuest -- the player FSM,
+%%% acting for each of the players in the game.
+%%%
+%%% The FSM actually depends on no external events and only sends messages
+%%% to itself to prompt state changes. This is somewhat unusual as far as
+%%% gen_fsm usages go, but it's pretty useful when needing to work with
+%%% a standalone process.
+-module(pq_player).
+-behaviour(gen_fsm).
+-export([start_link/2]).
+-export([init/1, market/2, killing/2, handle_event/3, handle_sync_event/4,
+         handle_info/3, terminate/3, code_change/4]).
+
+-record(state, {name, stats, exp=0, lvlexp=1000, lvl=1,
+                equip=[], money=0, loot=[], bought=[],
+                time=0, quest}).
+
+
+%%% Possible states & events
+%%
+%      sell  buy
+%     /   | |  \
+%     \   ^ ^  /
+%      [market]<--,
+%      |          |
+% done buying     |
+%      |     bag full   
+%      v         /
+%  [killing fields]
+%   /   V   V   |
+%   \   /   |   |
+%   kill    lvl up
+
+start_link(Name, Opts) ->
+    gen_fsm:start_link(?MODULE, {Name, Opts}, []).
+
+init({Name, Opts}) ->
+    %% Properly seeding stuff. If not doing this, the random module will
+    %% seed it based on a slightly unique time value. However, when starting
+    %% many processes at about the same time, the seeds can be very close
+    %% and give barely random results. The crypto:rand_bytes/1 function
+    %% allows for much better seeding.
+    <<A:32, B:32, C:32>> = crypto:rand_bytes(12),
+    random:seed({A,B,C}),
+    %% The first event, to start the FSM
+    gen_fsm:send_event(self(), kill),
+    case regis:register(Name, self()) of
+        {error, _} ->
+            {stop, name_taken};
+        ok ->
+            %% Use proplists with default values to let the user configure
+            %% all parts of the FSM's state by using the Opts proplist.
+            S = #state{
+                name=Name,
+                stats=proplists:get_value(stats, Opts, pq_stats:initial_roll()),
+                exp=proplists:get_value(exp, Opts, 0),
+                lvlexp=proplists:get_value(lvlexp, Opts, 1000),
+                lvl=proplists:get_value(lvl, Opts, 1),
+                equip=proplists:get_value(equip, Opts, []),
+                money=proplists:get_value(money, Opts, 0),
+                loot=proplists:get_value(loot, Opts, []),
+                bought=proplists:get_value(bought, Opts, []),
+                time=proplists:get_value(time, Opts, 0),
+                quest=proplists:get_value(quest, Opts, pq_quest:fetch())
+            },
+            {ok, market, S}
+    end.
+
+%% Done selling. Switch to the event where we head to the killing fields
+market(sell, S = #state{loot=[]}) ->
+    gen_fsm:send_event(self(), buy),
+    {next_state, market, S};
+%% Selling an Item we have looted to the market, for whatever value it has
+market(sell, S = #state{loot=[{Drop,Val}|T], money=M, lvl=Lvl}) ->
+    pq_events:sell(S#state.name, {Drop, Val*Lvl}, S#state.time),
+    gen_fsm:send_event(self(), sell),
+    {next_state, market, S#state{loot=T, money=M+Val*Lvl}};
+%% When done selling, buy items with your money
+market(buy, S = #state{equip=Equip, money=Money, bought=Bought}) ->
+    %% we have slots of equipment. It's useless to buy the same
+    %% kind of item time after time, so we must select one we haven't observed yet
+    case next_slot(Equip, Bought) of
+        undefined ->
+            %% when no slot is found, go to the killing field
+            gen_fsm:send_event(self(), kill),
+            {next_state, market, S#state{bought=[]}};
+        OldItem = {Slot, {_Name, Modifier, Lvl, _Price}} ->
+            %% Replace the item by a slightly better one if possible.
+            case pq_market:Slot(Modifier+Lvl, Money) of
+                undefined ->
+                    market(buy, S#state{bought=[Slot|Bought]});
+                NewItem = {_, _, _, Price} ->
+                    pq_events:buy(S#state.name, Slot, NewItem, S#state.time),
+                    gen_fsm:send_event(self(), buy),
+                    NewEquip = [{Slot, NewItem} | Equip -- [OldItem]],
+                    {next_state, market, S#state{equip=NewEquip,
+                                                 money=Money-Price,
+                                                 bought=[Slot|Bought]}}
+            end
+    end;
+%% Heading to the killing field. State only useful as a state transition.
+market(kill, S) ->
+    pq_events:location(S#state.name, killing, S#state.time),
+    gen_fsm:send_event(self(), kill),
+    {next_state, killing, S}.
+
+%% Killing an enemy on the killing field. Taking its drop and keeping it
+%% in our loot.
+killing(kill, S = #state{loot=Loot, stats=Stats, exp=Exp, lvlexp=LvlExp,
+                         quest=Quest}) ->
+    MaxSize = proplists:get_value(strength, Stats)*2,
+    {EnemyName, Props} = pq_enemy:fetch(),
+    pq_events:killed(S#state.name, {EnemyName, Props}, S#state.time),
+    Drop = {_N, _V} = proplists:get_value(drop, Props),
+    KillExp = proplists:get_value(experience, Props),
+    NewLoot = [Drop|Loot],
+    {QuestExp, NewQuest} = case check_quest(Quest) of
+        UpdatedQuest = {0, _} -> UpdatedQuest;
+        QuestBeaten = {_, NewQuest0} ->
+            pq_events:quest(S#state.name, Quest, NewQuest0, S#state.time),
+            QuestBeaten
+    end,
+    if length(NewLoot) =:= MaxSize ->
+        gen_fsm:send_event(self(), market);
+       Exp+KillExp+QuestExp >= LvlExp ->
+        gen_fsm:send_event(self(), lvl_up);
+       true ->
+        gen_fsm:send_event(self(), kill)
+    end,
+    {next_state, killing, S#state{loot=NewLoot,
+                                  exp=Exp+KillExp+QuestExp,
+                                  quest=NewQuest}};
+%% If we just leveled up, the stats get updated before we keep killing.
+killing(lvl_up, S = #state{stats=Stats, lvl=Lvl, lvlexp=LvlExp}) ->
+    NewStats = [{charisma, proplists:get_value(charisma, Stats)+pq_stats:roll()},
+     {constitution, proplists:get_value(constitution, Stats)+pq_stats:roll()},
+     {dexterity, proplists:get_value(dexterity, Stats)+pq_stats:roll()},
+     {intelligence, proplists:get_value(intelligence, Stats)+pq_stats:roll()},
+     {strength, proplists:get_value(strength, Stats)+pq_stats:roll()},
+     {wisdom, proplists:get_value(wisdom, Stats)+pq_stats:roll()}],
+    gen_fsm:send_event(self(), kill),
+    pq_events:lvl_up(S#state.name, NewStats, Lvl+1, LvlExp*2, S#state.time),
+    {next_state, killing, S#state{stats=NewStats, lvl=Lvl+1, lvlexp=LvlExp*2}};
+%% Heading to the market state transition
+killing(market, S) ->
+    pq_events:location(S#state.name, market, S#state.time),
+    gen_fsm:send_event(self(), sell),
+    {next_state, market, S}.
+
+handle_event(_Event, StateName, State) ->
+    {next_state, StateName, State}.
+
+handle_sync_event(_Event, _From, StateName, State) ->
+    {next_state, StateName, State}.
+
+handle_info(_Event, StateName, State) ->
+    {next_state, StateName, State}.
+
+terminate(_Reason, _StateName, _State) ->
+    ok.
+
+code_change({down, _},
+            StateName,
+            #state{name=N, stats=S, exp=E, lvlexp=LE, lvl=L, equip=Eq,
+                   money=M, loot=Lo, bought=B, time=T},
+            _Extra) ->
+    Old = {state, N, S, E, LE, L, Eq, M, Lo, B, T},
+    {ok, StateName, Old};
+code_change(_OldVsn,
+            StateName,
+            {state, Name, Stats, Exp, LvlExp, Lvl, Equip, Money, Loot,
+             Bought, Time},
+             _Extra) ->
+    State = #state{
+        name=Name, stats=Stats, exp=Exp, lvlexp=LvlExp, lvl=Lvl, equip=Equip,
+        money=Money, loot=Loot, bought=Bought, time=Time, quest=pq_quest:fetch()
+    },
+    {ok, StateName, State}.
+
+%%%%%%%%%%%%%%%
+%%% PRIVATE %%%
+%%%%%%%%%%%%%%%
+
+%% Picks a slot based on what has been seen so far, combined with the
+%% current weakest item.
+next_slot(Equip, Bought) ->
+    L = expand(Equip),
+    case lists:sort([{Mod+Lvl, Entry} || Entry = {Slot, {_, Mod, Lvl, _}} <- L,
+                                         not lists:member(Slot, Bought)]) of
+        [] -> undefined;
+        [{_, Entry}|_] -> Entry
+    end.
+
+expand(L) ->
+    [expand_field(armor, L),
+     expand_field(helmet, L),
+     expand_field(shield, L),
+     expand_field(weapon, L)].
+
+expand_field(F, L) ->
+    {F, proplists:get_value(F, L, {undefined,0,0,0})}.
+
+%% Checks quests, if they are ready for the next level or not
+check_quest({Name, Props}) ->
+    case proplists:get_value(kills, Props) of
+        1 ->
+            case pq_quest:fetch() of
+                %% Same name, we want new stuff!
+                {Name, _} -> check_quest({Name, Props});
+                NewQuest ->
+                    Exp = proplists:get_value(experience, Props),
+                    {Exp, NewQuest}
+            end;
+        Q ->
+            {0, {Name, [{kills,Q-1} | Props--[{kills,Q}]]}}
+    end.
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_quest.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_quest.erl
new file mode 100644
index 0000000..b8294fb
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_quest.erl
@@ -0,0 +1,15 @@
+-module(pq_quest).
+-export([fetch/0]).
+
+fetch() ->
+    L = quests(),
+    lists:nth(random:uniform(length(L)), L).
+
+quests() ->
+    [{<<"Fetch me a nut">>, [{experience, 150}, {kills, 20}]},
+     {<<"Cancel the festival">>, [{experience, 65}, {kills, 8}]},
+     {<<"Summon the dragon">>, [{experience, 1000}, {kills, 100}]},
+     {<<"Meet the invisible man">>, [{experience, 200}, {kills, 25}]},
+     {<<"Find quest ideas">>, [{experience, 340}, {kills, 32}]},
+     {<<"Invent maple syrup">>, [{experience, 1500}, {kills, 175}]},
+     {<<"Slay the Bieber">>, [{experience, 500}, {kills, 45}]}].
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_stats.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_stats.erl
new file mode 100644
index 0000000..379f5e9
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_stats.erl
@@ -0,0 +1,19 @@
+%%% Rolls dice to generate statistics or level increases for a character
+-module(pq_stats).
+-export([initial_roll/0, roll/0]).
+
+%% First roll, when setting the stats up for the first time
+initial_roll() ->
+    [{charisma, roll(3)},
+     {constitution, roll(3)},
+     {dexterity, roll(3)},
+     {intelligence, roll(3)},
+     {strength, roll(3)},
+     {wisdom, roll(3)}].
+
+%% Rolls a single die. Used when leveling up
+roll() -> roll(1).
+
+%% Rolls Num 6-faced dice
+roll(Num) ->
+    lists:sum([random:uniform(6) || _ <- lists:seq(1,Num)]).
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_sup.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_sup.erl
new file mode 100644
index 0000000..de89a9a
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_sup.erl
@@ -0,0 +1,31 @@
+%%% Supervisor for each player. Goes over a pair of a
+%%% gen_fsm (pq_player) and gen_event (pq_events).
+-module(pq_sup).
+-behaviour(supervisor).
+-export([start_link/2]).
+-export([init/1]).
+
+
+start_link(Name, Info) ->
+    supervisor:start_link(?MODULE, {Name,Info}).
+
+%% The name is passed to the events so that
+%% it can register itself as {events, Name} into the
+%% 'regis' regsitry app.
+%% Same for pq_player, which also gets the info.
+%%
+%% It is important that pq_events is started before
+%% pq_player, otherwise we might create race conditions
+%% when starting a player and then quickly generating events to
+%% an event manager that doesn't exist.
+init({Name, Info}) ->
+    {ok,
+     {{one_for_all, 2, 3600},
+      [{events,
+        {pq_events, start_link, [Name]},
+        permanent, 5000, worker, [dynamic]},
+       {player,
+        {pq_player, start_link, [Name, Info]},
+        permanent, 2000, worker, [pq_player]}]}}.
+
+
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_supersup.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_supersup.erl
new file mode 100644
index 0000000..577bbed
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/pq_supersup.erl
@@ -0,0 +1,28 @@
+%%% pq_supersup is the ProcessQuest top-level supervisor.
+%%% It sits over many pq_sup instances, allowing to have
+%%% a truckload of different players running at once.
+-module(pq_supersup).
+-behaviour(supervisor).
+-export([start_link/0, start_player/2, stop_player/1]).
+-export([init/1]).
+
+%% We register it so that it's guaranteed to be unique
+start_link() ->
+    supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
+%% Using a SOFO strategy because we get to have many
+%% supervisees of the same type.
+init([]) ->
+    {ok,
+     {{simple_one_for_one, 1, 60000},
+      [{sup,
+        {pq_sup, start_link, []},
+        permanent, infinity, supervisor, [pq_sup]}]}}.
+
+%% Starts an individual player
+start_player(Name, Info) ->
+    supervisor:start_child(?MODULE, [Name, Info]).
+
+%% Stops a player.
+stop_player(Name) ->
+    supervisor:terminate_child(?MODULE, regis:whereis(Name)).
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/processquest.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/processquest.erl
new file mode 100644
index 0000000..469dcb0
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/src/processquest.erl
@@ -0,0 +1,39 @@
+%%% ProcessQuest's main wrapping module.
+%%% Start ProcessQuest by calling application:start(processquest).
+%%% Create a player by calling processquest:start_player(Name, Info).
+%%% - Name is any term to identify the player
+%%% - Info is additional information to configure the player. Consult
+%%%   the pq_player module for more info.
+%%%
+%%% You can subscribe to the player events by calling
+%%% processquest:subscribe(Name, Handler, Args).
+%%% The handler is a regular event handler. See test/pq_events_handler.erl.
+-module(processquest).
+-behaviour(application).
+-export([start/2, stop/1]).
+-export([start_player/2, stop_player/1, subscribe/3]).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% APPLICATION CALLBACKS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+start(normal, []) ->
+    pq_supersup:start_link().
+
+stop(_) -> ok.
+
+%%%%%%%%%%%%%%%%%%%%%%
+%%% USER INTERFACE %%%
+%%%%%%%%%%%%%%%%%%%%%%
+
+%% Starts a player
+start_player(Name, Info) ->
+    pq_supersup:start_player(Name, Info). 
+
+%% Stops a player
+stop_player(Name) ->
+    pq_supersup:stop_player(Name).
+
+%% Subscribe to user events
+subscribe(Name, Handler, Args) ->
+    pq_events:add_handler(Name, Handler, Args).
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_enemy_tests.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_enemy_tests.erl
new file mode 100644
index 0000000..14742fa
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_enemy_tests.erl
@@ -0,0 +1,33 @@
+-module(pq_enemy_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+is_random_test_() ->
+    F = fun(Parent, Ref) -> fun() ->
+        <<A:32,B:32,C:32>> = crypto:rand_bytes(12),
+        random:seed({A,B,C}),
+        Entries = [pq_enemy:fetch() || _ <- lists:seq(1,100)],
+        Parent ! {Ref, Entries}
+    end end,
+    Refs = [begin
+                Ref = make_ref(),
+                spawn_link(F(self(), Ref)),
+                Ref
+            end || _ <- lists:seq(1,3)],
+    [A,B,C] = [receive
+                {Ref, X} -> X
+               end || Ref <- Refs],
+    [?_assert(A =/= B),
+     ?_assert(A =/= C),
+     ?_assert(B =/= C)].
+
+format_test_() ->
+    [[?_assertMatch({_Name, [{drop, {_DropName, _DropVal}},
+                             {experience, _Exp}]}, pq_enemy:fetch())
+        || _ <- lists:seq(1,10)],
+     begin
+        {Name, [{drop, {Drop, Val}}, {experience, Exp}]} = pq_enemy:fetch(),
+        [?_assert(is_binary(Name)),
+         ?_assert(is_binary(Drop)),
+         ?_assert(is_integer(Val)),
+         ?_assert(is_integer(Exp))]
+     end].
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_events_handler.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_events_handler.erl
new file mode 100644
index 0000000..a02df4c
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_events_handler.erl
@@ -0,0 +1,24 @@
+%% A fake event handler used for tests
+-module(pq_events_handler).
+-behaviour(gen_event).
+-export([init/1, handle_event/2, handle_call/2, handle_info/2,
+         terminate/2, code_change/3]).
+
+init(Parent) -> {ok, Parent}.
+
+handle_event(E, Pid) ->
+    Pid ! E,
+    {ok, Pid}.
+
+handle_call(Req, Pid) ->
+    Pid ! Req,
+    {ok, ok, Pid}.
+
+handle_info(E, Pid) ->
+    Pid ! E,
+    {ok, Pid}.
+
+terminate(_, _) -> ok.
+
+code_change(_OldVsn, Pid, _Extra) ->
+    {ok, Pid}.
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_events_tests.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_events_tests.erl
new file mode 100644
index 0000000..3a327b7
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_events_tests.erl
@@ -0,0 +1,55 @@
+-module(pq_events_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+-define(setup(Name, T), {setup, fun() -> start(Name) end, fun stop/1, fun T/1}).
+-define(setup(T), ?setup(make_ref(), T)).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% TESTS DESCRIPTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%
+events_start_stop_reg_test_() ->
+    {"The event handler can be reached, started and stopped by using the "
+     "player's name",
+      ?setup(can_contact)}.
+
+%%%%%%%%%%%%%%%%%%%%%%%
+%%% SETUP FUNCTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%
+start(Name) ->
+    application:start(regis),
+    {ok, Pid} = pq_events:start_link(Name),
+    unlink(Pid),
+    Name.
+
+stop(Name) ->
+    pq_events:stop(Name).
+
+%%%%%%%%%%%%%%%%%%%%
+%%% ACTUAL TESTS %%%
+%%%%%%%%%%%%%%%%%%%%
+can_contact(Name) ->
+    ok = pq_events:add_handler(Name, pq_events_handler, self()),
+    pq_events:notify(Name, hello),
+    L1 = flush(),
+    pq_events:delete_handler(Name, pq_events_handler, []),
+    pq_events:notify(Name, hello),
+    L2 = flush(),
+    [?_assertEqual([hello], L1),
+     ?_assertEqual([], L2)].
+    
+%%%%%%%%%%%%%%%%%%%%%%%%
+%%% HELPER FUNCTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%
+flush() ->
+    receive
+        X -> [X | flush1()]
+    after 300 ->
+        []
+    end.
+
+flush1() ->
+    receive
+        X -> [X | flush1()]
+    after 0 ->
+        []
+    end.
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_market_tests.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_market_tests.erl
new file mode 100644
index 0000000..d689f67
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_market_tests.erl
@@ -0,0 +1,15 @@
+-module(pq_market_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+best_smallest_weapon_test_() ->
+    [?_assertMatch({<<"plastic knife">>, 0, 1, 3}, pq_market:weapon(0, 5)),
+     ?_assertMatch({<<"plastic knife">>, 1, 1, 5}, pq_market:weapon(1, 100)),
+     ?_assertMatch(undefined, pq_market:weapon(0,0)),
+     ?_assertMatch(undefined, pq_market:weapon(50000,100000000000000000000))].
+
+best_smallest_gear_test_() ->
+    [[?_assertMatch({<<"wool">>, 0, 1, 25}, pq_market:F(0, 35)),
+      ?_assertMatch({<<"pleather">>, 0, 2, 45}, pq_market:F(1, 100)),
+      ?_assertMatch(undefined, pq_market:F(0,0)),
+      ?_assertMatch(undefined, pq_market:F(50000,100000000000000000000))]
+        || F <- [helmet, shield, armor]].
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_player_tests.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_player_tests.erl
new file mode 100644
index 0000000..d0f9c62
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_player_tests.erl
@@ -0,0 +1,395 @@
+-module(pq_player_tests).
+-include_lib("eunit/include/eunit.hrl").
+-record(state, {name, stats, exp=0, lvlexp=1000, lvl=1, % copied from pq_player.erl
+                 equip=[], money=0, loot=[], bought=[],
+                 time=0, quest}).
+
+-define(setup(Name, T), {setup, fun() -> start(Name) end, fun stop/1, fun T/1}).
+-define(setup(T), ?setup(make_ref(), T)).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% TESTS DESCRIPTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%
+new_player_test_() ->
+    [{"A player holds its own name in its state",
+      ?setup(initial_name)},
+     {"A new player has stats randomly rolled",
+      ?setup(initial_roll)},
+     {"A new player becomes a registered process",
+      ?setup(initial_register)},
+     {"A player has a counter for experience and a counter for "
+      "the next level (which is higher than the current exp)",
+      ?setup(initial_lvl)},
+     {"A player has a basic equipment (empty) when first going",
+      ?setup(initial_equipment)},
+     {"A new player has no money",
+      ?setup(initial_money)},
+     {"A new player has no loot",
+      ?setup(initial_loot)},
+     {"A new player has a quest given to him",
+      ?setup(initial_quest)},
+     {"The state of a player can be overriden using the info "
+      "arguments to the init function",
+      ?setup(override_init)}].
+
+market_test_() ->
+    [{"A player with N items will sell all of them to the market "
+      "and end with equivalent money, before switching to the "
+      "buying state",
+      ?setup(sell_all)},
+     {"A player with nearly infinite money will buy items available "
+      "for his money, higher than his level",
+      ?setup(buy_items)},
+     {"A player with no money or no items available for the price "
+      "range leaves for the killing fields.",
+      ?setup(buy_none)},
+     {"Receiving the kill message just forwards to the killing state",
+      ?setup(to_killing)}].
+
+killing_fields_test_() ->
+    [{"Kill enemies until the loot limit is hit. Loot is 2x Strength",
+      ?setup(loot_limit)},
+     {"Killing enemies raises XP until someone levels up",
+      ?setup(kill_xp)},
+     {"Leveling up boosts stats. The sum is higher by at least as "
+      "many points as there are fields, but not more than 6 times. "
+      "Moreover, the rolling is random.",
+      ?setup(lvl_stats)},
+     {"receiving the market message just forwards to the market state",
+      ?setup(to_market)}].
+
+quest_test_() ->
+    [{"A player who kills enough enemies to complete a quest obtains "
+      "a new, different one",
+      ?setup(quest_change)},
+     {"A player who kills an enemy sees the quest kill count change",
+      ?setup(quest_kill_count)},
+     {"A player who completes a quest obtains XP in exchange",
+      ?setup(quest_exp)}].
+
+code_change_test_() ->
+    [{"Updating", update()},
+     {"Downgrading", downgrade()}].
+
+%%%%%%%%%%%%%%%%%%%%%%%
+%%% SETUP FUNCTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%
+start(Name) ->
+    application:start(crypto),
+    application:start(regis),
+    Pid = spawn(fun() -> timer:sleep(infinity) end),
+    regis:register({events, Name}, Pid),
+    Name.
+
+stop(Name) ->
+    exit(regis:whereis({events, Name}), kill),
+    application:stop(regis),
+    application:stop(crypto).
+
+%%%%%%%%%%%%%%%%%%%%
+%%% ACTUAL TESTS %%%
+%%%%%%%%%%%%%%%%%%%%
+
+%% Initial State
+initial_name(Name) ->
+    {ok, market, S} = pq_player:init({Name, []}),
+    M = read_event(),
+    [?_assertEqual(Name, S#state.name),
+     ?_assertEqual(M, kill)].
+
+initial_roll(Name) ->
+    {ok, _, S} = pq_player:init({Name, []}),
+    _ = read_event(),
+    ?_assertMatch([{charisma,_}, {constitution, _}, {dexterity, _},
+                   {intelligence, _}, {strength, _}, {wisdom, _}],
+                  lists:sort(S#state.stats)).
+
+initial_register(Ref) ->
+    {ok, _, _} = pq_player:init({Ref, []}),
+    _ = read_event(),
+    Pid = regis:whereis(Ref),
+    Ret = pq_player:init({Ref, []}),
+    _ = read_event(),
+    [?_assert(undefined =/= Pid),
+     ?_assert(is_pid(Pid)),
+     ?_assertEqual({stop, name_taken}, Ret)].
+
+initial_lvl(Name) ->
+    {ok, _, S} = pq_player:init({Name, []}),
+    _ = read_event(),
+    [?_assert(is_integer(S#state.lvlexp)),
+     ?_assert(S#state.lvlexp > 0),
+     ?_assert(S#state.exp =:= 0)]. % start at 0 exp
+
+initial_equipment(Name) ->
+    {ok, _, S} = pq_player:init({Name, []}),
+    _ = read_event(),
+    [?_assert(is_list(S#state.equip)),
+     ?_assertEqual(undefined, proplists:get_value(armor, S#state.equip)),
+     ?_assertEqual(undefined, proplists:get_value(helmet, S#state.equip)),
+     ?_assertEqual(undefined, proplists:get_value(weapon, S#state.equip)),
+     ?_assertEqual(undefined, proplists:get_value(shield, S#state.equip))].
+
+initial_money(Name) ->
+    {ok, _, S} = pq_player:init({Name, []}),
+    _ = read_event(),
+    ?_assertEqual(0, S#state.money).
+
+initial_loot(Name) ->
+    {ok, _, S} = pq_player:init({Name, []}),
+    _ = read_event(),
+    ?_assertEqual([], S#state.loot).
+
+initial_quest(Name) ->
+    {ok, _, S} = pq_player:init({Name, []}),
+    _ = read_event(),
+    ?_assertMatch({_QuestName, _Props}, S#state.quest).
+
+override_init(Name) ->
+    {ok, _, Partial} = pq_player:init({Name, [
+        {stats, [{charisma,1}, {constitution,1}, {dexterity,1},
+                 {intelligence,1}, {strength,1}, {wisdom,1}]},
+        {lvlexp,1}]}),
+    regis:unregister(Name),
+    _ = read_event(),
+    {ok, _, Complete} = pq_player:init({Name, [
+        {stats, [{charisma,1}, {constitution,1}, {dexterity,1},
+                 {intelligence,1}, {strength,1}, {wisdom,1}]},
+        {exp, 1}, {lvlexp,1}, {lvl,9},
+        {equip, [{weapon,{<<"plastic knife">>, -1, 1, 2}}]},
+        {money,1}, {loot, [{<<"Bacon">>, 1}]}, {bought, [helmet]},
+        {time, 1},
+        {quest, {<<"A">>, [{experience, 1},{kills,1}]}}
+    ]}),
+    _ = read_event(),
+    [?_assertMatch(#state{stats=[{_,1},{_,1},{_,1},{_,1},{_,1},{_,1}],
+                          lvlexp=1, lvl=1, exp=0},
+                   Partial),
+     ?_assertMatch(#state{stats=[{_,1},{_,1},{_,1},{_,1},{_,1},{_,1}],
+                          exp=1, lvlexp=1, lvl=9, equip=[{weapon,_}],
+                          money=1, loot=[{_,_}], bought=[_], time=1,
+                          quest={<<"A">>, [_|_]}},
+                   Complete)].
+
+%% Market
+sell_all(Name) ->
+    Loot = [proplists:get_value(drop, element(2, pq_enemy:fetch()))
+             || _ <- lists:seq(1,5)],
+    [{_, LV1}, {_, LV2}, {_, LV3}, {_, LV4}, {_, LV5}] = Loot,
+    LootVals = [LV1, LV2*2, LV3*3, LV4*4, LV5*5],
+    {[Sum1, Sum2, Sum3, Sum4, Sum5], _} = lists:mapfoldl(
+        fun(X, Sum) -> {X+Sum, X+Sum} end,
+        0,
+        LootVals
+    ),
+    undefined = read_event(),
+    S0 = #state{name=Name, loot=Loot, money=0},
+    {next_state, market, S1} = pq_player:market(sell, S0),
+    M1 = read_event(),
+    {next_state, market, S2} = pq_player:market(sell, S1#state{lvl=2}),
+    M2 = read_event(),
+    {next_state, market, S3} = pq_player:market(sell, S2#state{lvl=3}),
+    M3 = read_event(),
+    {next_state, market, S4} = pq_player:market(sell, S3#state{lvl=4}),
+    M4 = read_event(),
+    {next_state, market, S5} = pq_player:market(sell, S4#state{lvl=5}),
+    M5 = read_event(),
+    {next_state, market, S6} = pq_player:market(sell, S5#state{lvl=6}),
+    M6 = read_event(),
+    [?_assertMatch(#state{money=Sum1, loot=[_,_,_,_]}, S1),
+     ?_assertMatch(#state{money=Sum2, loot=[_,_,_]}, S2),
+     ?_assertMatch(#state{money=Sum3, loot=[_,_]}, S3),
+     ?_assertMatch(#state{money=Sum4, loot=[_]}, S4),
+     ?_assertMatch(#state{money=Sum5, loot=[]}, S5),
+     ?_assertMatch(#state{money=Sum5, loot=[]}, S6),
+     ?_assertEqual([sell, sell, sell, sell, sell, buy],
+                   [M1,M2,M3,M4,M5,M6])].
+
+buy_items(Name) ->
+    %% 4 different pieces of equipment to buy
+    S0 = #state{name=Name, equip=[], money=999999999999},
+    {next_state, market, S1} = pq_player:market(buy, S0),
+    M1 = read_event(),
+    {next_state, market, S2} = pq_player:market(buy, S1),
+    M2 = read_event(),
+    {next_state, market, S3} = pq_player:market(buy, S2),
+    M3 = read_event(),
+    {next_state, market, S4} = pq_player:market(buy, S3),
+    M4 = read_event(),
+    %% All slots bought. Implicit requirement: not buying for the
+    %% same slot twice.
+    {next_state, market, S5} = pq_player:market(buy, S4),
+    M5 = read_event(),
+    [?_assertEqual([S5#state.money, S4#state.money, S3#state.money,
+                    S2#state.money, S1#state.money, S0#state.money],
+                   lists:sort([S5#state.money, S4#state.money, S3#state.money,
+                          S2#state.money, S1#state.money, S0#state.money])),
+     ?_assertEqual([1,2,3,4,4],
+                   [length(L) || L <- [S1#state.equip, S2#state.equip,
+                                       S3#state.equip, S4#state.equip,
+                                       S5#state.equip]]),
+     ?_assertEqual([buy, buy, buy, buy, kill],
+                   [M1, M2, M3, M4, M5])]. 
+
+buy_none(Name) ->
+    S0 = #state{name=Name, equip=[], money=0},
+    %% one try per part of the equipment
+    {next_state, market, S1} = pq_player:market(buy, S0),
+    _ = read_event(),
+    {next_state, market, S2} = pq_player:market(buy, S1),
+    _ = read_event(),
+    {next_state, market, S3} = pq_player:market(buy, S2),
+    _ = read_event(),
+    {next_state, market, S4} = pq_player:market(buy, S3),
+    M = read_event(),
+    [?_assertEqual(S0, S4),
+     ?_assertEqual(kill, M)].
+
+to_killing(Name) ->
+    S = #state{name=Name},
+    Res = pq_player:market(kill, S),
+    M = read_event(),
+    [?_assertMatch({next_state, killing, S}, Res),
+     ?_assertEqual(kill, M)].
+
+%% Killing fields tests
+loot_limit(Name) ->
+    S0 = #state{name=Name, stats=[{strength, 2}], loot=[],
+                quest={<<1>>,[{experience,0},{kills,10000}]}},
+    {next_state, killing, S1 = #state{loot=L1}} = pq_player:killing(kill, S0),
+    M1 = read_event(),
+    {next_state, killing, S2 = #state{loot=L2}} = pq_player:killing(kill, S1),
+    M2 = read_event(),
+    {next_state, killing, S3 = #state{loot=L3}} = pq_player:killing(kill, S2),
+    M3 = read_event(),
+    {next_state, killing, #state{loot=L4}} = pq_player:killing(kill, S3),
+    M4 = read_event(),
+    %% Group identical drops with a counter?
+    [?_assertEqual([1,2,3,4], [length(L) || L <- [L1, L2, L3, L4]]),
+     ?_assertEqual([kill, kill, kill, market], [M1, M2, M3, M4])].
+
+kill_xp(Name) ->
+    S0 = #state{name=Name, stats=[{strength, 999}|pq_stats:initial_roll()],
+                lvl=1, exp=0, lvlexp=5,
+                quest={<<1>>,[{experience,0},{kills,10000}]}},
+    %% between 1 and 5 kills required to lvl up.
+    {next_state, NS1, S1} = pq_player:killing(kill, S0),
+    M1 = read_event(),
+    {next_state, NS2, S2} = pq_player:NS1(M1, S1),
+    M2 = read_event(),
+    {next_state, NS3, S3} = pq_player:NS2(M2, S2),
+    M3 = read_event(),
+    {next_state, NS4, S4} = pq_player:NS3(M3, S3),
+    M4 = read_event(),
+    {next_state, NS5, S5} = pq_player:NS4(M4, S4),
+    M5 = read_event(),
+    {next_state, NS6, S6} = pq_player:NS5(M5, S5),
+    M6 = read_event(),
+    [?_assert(lists:any(fun(#state{lvl=L}) -> L > 1 end, [S1,S2,S3,S4,S5,S6])),
+     ?_assert(lists:any(fun(#state{lvlexp=L}) -> L >= 10 end, [S1,S2,S3,S4,S5,S6])),
+     ?_assert(lists:any(fun(#state{exp=E}) -> E >= 5 end, [S1,S2,S3,S4,S5,S6])),
+     ?_assert(lists:any(fun(FSMState) -> FSMState =:= killing end,
+                        [NS1, NS2, NS3, NS4, NS5, NS6])),
+     ?_assert(lists:any(fun(Msg) -> Msg =:= kill end,
+                        [M1, M2, M3, M4, M5, M6])),
+     ?_assert(lists:any(fun(Msg) -> Msg =:= lvl_up end,
+                        [M1, M2, M3, M4, M5, M6]))].
+
+lvl_stats(Name) ->
+    {ok, _, S0} = pq_player:init({Name, []}),
+    _ = read_event(),
+    TotalStats = length(S0#state.stats),
+    {next_state, killing, S1} = pq_player:killing(lvl_up, S0),
+    _ = read_event(),
+    {next_state, killing, S2} = pq_player:killing(lvl_up, S0),
+    _ = read_event(),
+    SumInit = lists:sum([Pts || {_,Pts} <- S0#state.stats]),
+    SumS1 = lists:sum([Pts || {_,Pts} <- S1#state.stats]),
+    SumS2 = lists:sum([Pts || {_,Pts} <- S2#state.stats]),
+    [?_assert(SumS1 >= TotalStats+SumInit),
+     ?_assert(SumS2 >= TotalStats+SumInit),
+     ?_assert(SumS1 =< TotalStats*6 + SumInit),
+     ?_assert(SumS2 =< TotalStats*6 + SumInit),
+     ?_assert(S1#state.stats =/= S2#state.stats)].
+
+to_market(Name) ->
+    S = #state{name=Name},
+    Res = pq_player:killing(market, S),
+    M = read_event(),
+    [?_assertMatch({next_state, market, S}, Res),
+     ?_assertEqual(sell, M)].
+
+%% Quests
+quest_change(Name) ->
+    {ok, _, S0=#state{quest={N, Props}}} = pq_player:init({Name, []}),
+    _ = read_event(),
+    S = S0#state{quest={N, [{kills,1}|Props]}},
+    States = [element(3, pq_player:killing(kill, S)) || _ <- lists:seq(1,10)],
+    [read_event() || _ <- lists:seq(1,10)],
+    [?_assert(lists:all(fun(#state{quest={QName, _}}) -> QName =/= N end,
+                        States))].
+
+quest_kill_count(Name) ->
+    {ok, _, S0=#state{quest={N, Props}}} = pq_player:init({Name, []}),
+    _ = read_event(),
+    S1 = S0#state{quest={N, [{kills,3}|Props]}},
+    {next_state, _, S2} = pq_player:killing(kill, S1),
+    _ = read_event(),
+    [?_assertEqual(2, proplists:get_value(kills,element(2,S2#state.quest)))].
+
+quest_exp(Name) ->
+    {ok, _, S0=#state{quest={N, _Props}}} = pq_player:init({Name, [{lvl,0},{exp,0}]}),
+    _ = read_event(),
+    S1 = S0#state{quest={N, [{kills,2},{experience, 100000}]}},
+    {next_state, _, S2 = #state{exp=E1}} = pq_player:killing(kill, S1),
+    _ = read_event(),
+    {next_state, _, #state{exp=E2}} = pq_player:killing(kill, S2),
+    _ = read_event(),
+    [?_assert(E1 < 100000),
+     ?_assert(E2 > 100000)].
+
+%% Update/Downgrade
+
+update() ->
+    Stats = [{charisma,1}, {constitution,1}, {dexterity,1},
+             {intelligence,1}, {strength,1}, {wisdom,1}],
+    OldState = {state, joe,
+                Stats,
+                1, % exp
+                2, % lvlexp
+                3, % lvl
+                [{weapon,{<<"a">>, -1, 1, 2}}], % equip
+                4, % money
+                [{<<"b">>, 1}], % loot
+                [helmet], % bought
+                5 % time
+    },
+    ?_assertMatch({ok,
+                   market,
+                   #state{name=joe, stats=Stats, exp=1, lvlexp=2,
+                          lvl=3, equip=[{weapon,{<<"a">>,-1,1,2}}],
+                          money=4, loot=[{<<"b">>,1}], bought=[helmet],
+                          quest={_, [_|_]}}},
+                  pq_player:code_change("some version hash", market, OldState, none)).
+
+downgrade() ->
+    Stats = [{charisma,1}, {constitution,1}, {dexterity,1},
+             {intelligence,1}, {strength,1}, {wisdom,1}],
+    State = #state{name=joe, stats=Stats, exp=1, lvlexp=2,
+                             lvl=3, equip=[{weapon,{<<"a">>,-1,1,2}}],
+                             money=4, loot=[{<<"b">>,1}], bought=[helmet],
+                             time=5, quest={<<"this goes">>, []}},
+    NewState = {state, joe, Stats, 1, 2, 3, [{weapon,{<<"a">>, -1, 1, 2}}],
+               4, [{<<"b">>, 1}], [helmet], 5},
+    ?_assertMatch({ok, market, NewState},
+                  pq_player:code_change({down, "old vsn hash"}, market, State, none)).
+
+%%%%%%%%%%%%%%%%%%%%%%%%
+%%% HELPER FUNCTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%
+read_event() ->
+    receive
+        {'$gen_event', Msg} -> Msg
+    after 0 ->
+        undefined
+    end.
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_quest_tests.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_quest_tests.erl
new file mode 100644
index 0000000..4e4f98c
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_quest_tests.erl
@@ -0,0 +1,30 @@
+-module(pq_quest_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+format_test_() ->
+    Quest = pq_quest:fetch(),
+    [?_assertMatch({_Name, _Props}, Quest),
+     ?_assert(is_binary(element(1,Quest))),
+     ?_assert(is_integer(proplists:get_value(kills, element(2,Quest)))),
+     ?_assert(0 < proplists:get_value(kills, element(2,Quest))),
+     ?_assert(is_integer(proplists:get_value(experience, element(2,Quest)))),
+     ?_assert(0 < proplists:get_value(experience, element(2,Quest)))].
+
+is_random_test_() ->
+    F = fun(Parent, Ref) -> fun() ->
+        <<A:32,B:32,C:32>> = crypto:rand_bytes(12),
+        random:seed({A,B,C}),
+        Entries = [pq_quest:fetch() || _ <- lists:seq(1,100)],
+        Parent ! {Ref, Entries}
+    end end,
+    Refs = [begin
+                Ref = make_ref(),
+                spawn_link(F(self(), Ref)),
+                Ref
+            end || _ <- lists:seq(1,3)],
+    [A,B,C] = [receive
+                {Ref, X} -> X
+               end || Ref <- Refs],
+    [?_assert(A =/= B),
+     ?_assert(A =/= C),
+     ?_assert(B =/= C)].
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_stats_tests.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_stats_tests.erl
new file mode 100644
index 0000000..da9daa5
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/pq_stats_tests.erl
@@ -0,0 +1,28 @@
+-module(pq_stats_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+all_stats_test_() ->
+    Stats = pq_stats:initial_roll(),
+    {"Checks whether all stats are returned",
+     [?_assertEqual([charisma, constitution, dexterity,
+                     intelligence, strength, wisdom],
+                    lists:sort(proplists:get_keys(Stats)))]}.
+
+initial_roll_test_() ->
+    Rolls = [pq_stats:initial_roll() || _ <- lists:seq(1,100)],
+    {"All die rolls are made out of 3 d6 dice",
+     %% 6 == number of stats
+     [?_assertEqual(6, length([S || {_,S} <- Stats, S >= 3, S =< 18]))
+        || Stats <- Rolls]}.
+
+initial_random_roll_test_() ->
+    Stats = [pq_stats:initial_roll() || _ <- lists:seq(1,100)],
+    {"All die rolls are random",
+     ?_assertEqual(lists:sort(Stats),
+                   lists:sort(sets:to_list(sets:from_list(Stats))))}.
+
+single_die_roll_test_() ->
+    Rolls = [pq_stats:roll() || _ <- lists:seq(1,100)],
+    [?_assertEqual(100, length([N || N <- Rolls, N >= 1, N =< 6])),
+     ?_assert(1 =/= length(sets:to_list(sets:from_list(Rolls))))].
+
diff --git a/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/processquest_tests.erl b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/processquest_tests.erl
new file mode 100644
index 0000000..fa118b1
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/processquest-1.1.0/test/processquest_tests.erl
@@ -0,0 +1,49 @@
+-module(processquest_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+%%% Integration tests verifying the whole app.
+-define(setup(Name, T), {setup, fun() -> start(Name) end, fun stop/1, fun T/1}).
+-define(setup(T), ?setup(make_ref(), T)).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% TESTS DESCRIPTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%
+integration_test_() ->
+    [{"A player can be started from the processquest module and monitored",
+     ?setup(subscribe)}].
+
+%%%%%%%%%%%%%%%%%%%%%%%
+%%% SETUP FUNCTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%
+start(Name) ->
+    application:start(crypto),
+    application:start(regis),
+    application:start(processquest),
+    processquest:start_player(Name, [{time,1100}]),
+    Name.
+
+stop(Name) ->
+    processquest:stop_player(Name),
+    application:stop(processquest),
+    application:stop(regis).
+
+%%%%%%%%%%%%%%%%%%%%
+%%% ACTUAL TESTS %%%
+%%%%%%%%%%%%%%%%%%%%
+subscribe(Name) ->
+    ok = processquest:subscribe(Name, pq_events_handler, self()),
+    timer:sleep(4000),
+    Msgs = flush(),
+    [?_assertMatch([{Name, killed, _Time1, {_EnemyName1, _Props1}},
+                    {Name, killed, _Time2, {_EnemyName2, _Props2}},
+                    {Name, killed, _Time3, {_EnemyName3, _Props3}}],
+                   Msgs)].
+
+%%%%%%%%%%%%%%%%%%%%%%%%
+%%% HELPER FUNCTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%
+flush() ->
+    receive
+        X -> [X | flush()]
+    after 0 -> []
+    end.
diff --git a/learn-you-some-erlang/processquest/apps/regis-1.0.0/Emakefile b/learn-you-some-erlang/processquest/apps/regis-1.0.0/Emakefile
new file mode 100644
index 0000000..b8be313
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/regis-1.0.0/Emakefile
@@ -0,0 +1,2 @@
+{["src/*", "test/*"], [{outdir, "ebin"}]}.
+
diff --git a/learn-you-some-erlang/processquest/apps/regis-1.0.0/ebin/regis.app b/learn-you-some-erlang/processquest/apps/regis-1.0.0/ebin/regis.app
new file mode 100644
index 0000000..169f6d2
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/regis-1.0.0/ebin/regis.app
@@ -0,0 +1,7 @@
+{application, regis,
+ [{description, "A non-distributed process registry"},
+  {vsn, "1.0.0"},
+  {mod, {regis, []}},
+  {registered, [regis_server]},
+  {modules, [regis, regis_sup, regis_server]},
+  {applications, [stdlib, kernel]}]}.
diff --git a/learn-you-some-erlang/processquest/apps/regis-1.0.0/src/regis.erl b/learn-you-some-erlang/processquest/apps/regis-1.0.0/src/regis.erl
new file mode 100644
index 0000000..0b37c7c
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/regis-1.0.0/src/regis.erl
@@ -0,0 +1,29 @@
+%%% Application wrapper module for regis,
+%%% a process registration application.
+%%%
+%%% This was added because the standard process registry has a precise
+%%% meaning of representing VM-global, non-dynamic processes.
+%%% However, for this, we needed dynamic names and so we had to write
+%%% one ourselves. Of course we could have used 'global' (but we
+%%% didn't see distributed Erlang yet) or 'gproc' (I don't want to
+%%% depend on external libs for this guide), so checkthem out
+%%% if you're writing your own app.
+-module(regis).
+-behaviour(application).
+-export([start/2, stop/1]).
+-export([register/2, unregister/1, whereis/1, get_names/0]).
+
+
+start(normal, []) ->
+    regis_sup:start_link().
+
+stop(_) ->
+    ok.
+
+register(Name, Pid) -> regis_server:register(Name, Pid).
+
+unregister(Name) -> regis_server:unregister(Name).
+
+whereis(Name) -> regis_server:whereis(Name).
+
+get_names() -> regis_server:get_names().
diff --git a/learn-you-some-erlang/processquest/apps/regis-1.0.0/src/regis_server.erl b/learn-you-some-erlang/processquest/apps/regis-1.0.0/src/regis_server.erl
new file mode 100644
index 0000000..a668b02
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/regis-1.0.0/src/regis_server.erl
@@ -0,0 +1,98 @@
+%%% The core of the app: the server in charge of tracking processes.
+-module(regis_server).
+-behaviour(gen_server).
+
+-export([start_link/0, stop/0, register/2, unregister/1, whereis/1,
+         get_names/0]).
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+         code_change/3, terminate/2]).
+
+%% We have two indexes: one by name and one by pid, for
+%% MAXIMUM SPEED (not actually measured).
+-record(state, {pid, name}).
+
+%%%%%%%%%%%%%%%%%
+%%% INTERFACE %%%
+%%%%%%%%%%%%%%%%%
+start_link() ->
+    gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).
+
+stop() ->
+    gen_server:call(?MODULE, stop).
+
+%% Give a name to a process
+register(Name, Pid) when is_pid(Pid) ->
+    gen_server:call(?MODULE, {register, Name, Pid}).
+
+%% Remove the name from a process
+unregister(Name) ->
+    gen_server:call(?MODULE, {unregister, Name}).
+
+%% Find the pid associated with a process
+whereis(Name) ->
+    gen_server:call(?MODULE, {whereis, Name}).
+
+%% Find all the names currently registered.
+get_names() ->
+    gen_server:call(?MODULE, get_names).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% GEN_SERVER CALLBACKS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+init([]) ->
+    %% Using gb_trees to store items. gb_trees generally have
+    %% good overall performance.
+    {ok, #state{pid = gb_trees:empty(),
+                name = gb_trees:empty()}}.
+
+handle_call({register, Name, Pid}, _From, S = #state{pid=P, name=N}) ->
+    case {gb_trees:is_defined(Pid, P), gb_trees:is_defined(Name, N)} of
+        {true, _} ->
+            {reply, {error, already_named}, S};
+        {_, true} ->
+            {reply, {error, name_taken}, S};
+        {false, false} ->
+            Ref = erlang:monitor(process, Pid),
+            {reply, ok, S#state{pid=gb_trees:insert(Pid, {Name,Ref}, P),
+                                name=gb_trees:insert(Name, {Pid,Ref}, N)}}
+    end;
+handle_call({unregister, Name}, _From, S = #state{pid=P, name=N}) ->
+    case gb_trees:lookup(Name, N) of
+        {value, {Pid,Ref}} ->
+            erlang:demonitor(Ref, [flush]),
+            {reply, ok, S#state{pid=gb_trees:delete(Pid, P),
+                                name=gb_trees:delete(Name, N)}};
+        none ->
+            {reply, ok, S}
+    end;
+handle_call({whereis, Name}, _From, S = #state{name=N}) ->
+    case gb_trees:lookup(Name, N) of
+        {value, {Pid,_}} ->
+            {reply, Pid, S};
+        none ->
+            {reply, undefined, S}
+    end;
+handle_call(get_names, _From, S = #state{name=N}) ->
+    {reply, gb_trees:keys(N), S};
+handle_call(stop, _From, State) ->
+    {stop, normal, ok, State};
+handle_call(_Event, _From, State) ->
+    {noreply, State}.
+
+handle_cast(_Event, State) ->
+    {noreply, State}.
+
+handle_info({'DOWN', Ref, process, Pid, _Reason}, S = #state{pid=P,name=N}) ->
+    {value, {Name, Ref}} = gb_trees:lookup(Pid, P),
+    {noreply, S#state{pid = gb_trees:delete(Pid, P),
+                 name = gb_trees:delete(Name, N)}};
+handle_info(_Event, State) ->
+    {noreply, State}.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+terminate(_Reason, _State) ->
+    ok.
+
+
diff --git a/learn-you-some-erlang/processquest/apps/regis-1.0.0/src/regis_sup.erl b/learn-you-some-erlang/processquest/apps/regis-1.0.0/src/regis_sup.erl
new file mode 100644
index 0000000..be333e6
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/regis-1.0.0/src/regis_sup.erl
@@ -0,0 +1,18 @@
+%%% The top-level supervisor of the registration
+%%% server.
+-module(regis_sup).
+-behaviour(supervisor).
+-export([start_link/0]).
+-export([init/1]).
+
+start_link() ->
+    supervisor:start_link(?MODULE, []).
+
+init([]) ->
+    {ok, {{one_for_one, 1, 3600},
+          [{server,
+           {regis_server, start_link, []},
+           permanent,
+           500,
+           worker,
+           [regis_server]}]}}.
diff --git a/learn-you-some-erlang/processquest/apps/regis-1.0.0/test/regis_server_tests.erl b/learn-you-some-erlang/processquest/apps/regis-1.0.0/test/regis_server_tests.erl
new file mode 100644
index 0000000..40e1af0
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/regis-1.0.0/test/regis_server_tests.erl
@@ -0,0 +1,120 @@
+-module(regis_server_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+-define(setup(F), {setup, fun start/0, fun stop/1, F}).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% TESTS DESCRIPTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+start_stop_test_() ->
+    {"The server can be started, stopped and has a registered name",
+     ?setup(fun is_registered/1)}.
+
+register_test_() ->
+    [{"A process can be registered and contacted",
+      ?setup(fun register_contact/1)},
+     {"A list of registered processes can be obtained",
+      ?setup(fun registered_list/1)},
+     {"An undefined name should return 'undefined' to crash calls",
+      ?setup(fun noregister/1)},
+     {"A process can not have two names",
+      ?setup(fun two_names_one_pid/1)},
+     {"Two processes cannot share the same name",
+      ?setup(fun two_pids_one_name/1)}].
+      
+unregister_test_() ->
+    [{"A process that was registered can be registered again iff it was "
+      "unregistered between both calls",
+      ?setup(fun re_un_register/1)},
+     {"Unregistering never crashes",
+      ?setup(fun unregister_nocrash/1)},
+     {"A crash unregisters a process",
+      ?setup(fun crash_unregisters/1)}].
+
+%%%%%%%%%%%%%%%%%%%%%%%
+%%% SETUP FUNCTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%
+start() ->
+    {ok, Pid} = regis_server:start_link(),
+    Pid.
+
+stop(_) ->
+    regis_server:stop().
+
+%%%%%%%%%%%%%%%%%%%%
+%%% ACTUAL TESTS %%%
+%%%%%%%%%%%%%%%%%%%%
+is_registered(Pid) ->
+    [?_assert(erlang:is_process_alive(Pid)),
+     ?_assertEqual(Pid, whereis(regis_server))].
+
+register_contact(_) ->
+    Pid = proc_lib:spawn_link(fun() -> callback(regcontact) end),
+    timer:sleep(15),
+    Ref = make_ref(),
+    WherePid = regis_server:whereis(regcontact),
+    regis_server:whereis(regcontact) ! {self(), Ref, hi},
+    Rec = receive
+         {Ref, hi} -> true
+         after 2000 -> false
+    end,
+    [?_assertEqual(Pid, WherePid),
+     ?_assert(Rec)].
+
+noregister(_) ->
+    [?_assertError(badarg, regis_server:whereis(make_ref()) ! hi),
+     ?_assertEqual(undefined, regis_server:whereis(make_ref()))].
+
+two_names_one_pid(_) ->
+    ok = regis_server:register(make_ref(), self()),
+    Res = regis_server:register(make_ref(), self()),
+    [?_assertEqual({error, already_named}, Res)].
+
+two_pids_one_name(_) ->
+    Pid = proc_lib:spawn(fun() -> callback(myname) end),
+    timer:sleep(15),
+    Res = regis_server:register(myname, self()),    
+    exit(Pid, kill),
+    [?_assertEqual({error, name_taken}, Res)].
+
+registered_list(_) ->
+    L1 = regis_server:get_names(),
+    Pids = [spawn(fun() -> callback(N) end) || N <- lists:seq(1,15)],
+    timer:sleep(200),
+    L2 = regis_server:get_names(),
+    [exit(Pid, kill) || Pid <- Pids],
+    [?_assertEqual([], L1),
+     ?_assertEqual(lists:sort(lists:seq(1,15)), lists:sort(L2))].
+
+re_un_register(_) ->
+    Ref = make_ref(),
+    L = [regis_server:register(Ref, self()),
+         regis_server:register(make_ref(), self()),
+         regis_server:unregister(Ref),
+         regis_server:register(make_ref(), self())],
+    [?_assertEqual([ok, {error, already_named}, ok, ok], L)].
+
+unregister_nocrash(_) ->
+    ?_assertEqual(ok, regis_server:unregister(make_ref())).
+
+crash_unregisters(_) ->
+    Ref = make_ref(),
+    Pid = spawn(fun() -> callback(Ref) end),
+    timer:sleep(150),
+    Pid = regis_server:whereis(Ref),
+    exit(Pid, kill),
+    timer:sleep(95),
+    regis_server:register(Ref, self()),
+    S = regis_server:whereis(Ref),
+    Self = self(),
+    ?_assertEqual(Self, S).
+
+%%%%%%%%%%%%%%%%%%%%%%%%
+%%% HELPER FUNCTIONS %%%
+%%%%%%%%%%%%%%%%%%%%%%%%
+callback(Name) ->
+    ok = regis_server:register(Name, self()),
+    receive
+        {From, Ref, Msg} -> From ! {Ref, Msg}
+    end.
diff --git a/learn-you-some-erlang/processquest/apps/regis-1.0.0/test/regis_tests.erl b/learn-you-some-erlang/processquest/apps/regis-1.0.0/test/regis_tests.erl
new file mode 100644
index 0000000..61f5f16
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/regis-1.0.0/test/regis_tests.erl
@@ -0,0 +1,18 @@
+-module(regis_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+app_test_() ->
+    {inorder,
+     [?_assert(try application:start(regis) of
+                 ok -> true;
+                 {error, {already_started, regis}} -> true;
+                 _ -> false
+               catch
+                 _:_ -> false
+               end),
+      ?_assert(try application:stop(regis) of
+                 ok -> true;
+                 _ -> false
+               catch
+                 _:_ -> false
+               end)]}.
diff --git a/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/Emakefile b/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/Emakefile
new file mode 100644
index 0000000..b203ea3
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/Emakefile
@@ -0,0 +1,2 @@
+{["src/*", "test/*"],
+ [{i,"include"}, {outdir, "ebin"}]}.
diff --git a/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/ebin/sockserv.app b/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/ebin/sockserv.app
new file mode 100644
index 0000000..dd6d8c7
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/ebin/sockserv.app
@@ -0,0 +1,11 @@
+{application, sockserv,
+ [{description, "Socket server to forward ProcessQuest messages to a client"},
+  {vsn, "1.0.0"},
+  {mod, {sockserv, []}},
+  {registered, [sockserv_sup]},
+  {modules, [sockserv, sockserv_sup, sockserv_serv, sockserv_trans,
+             sockserv_pq_events]},
+  {applications, [stdlib, kernel, processquest]},
+  {env,
+    [{port, 8082}]}
+ ]}.
diff --git a/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/src/sockserv.erl b/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/src/sockserv.erl
new file mode 100644
index 0000000..bd82b6d
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/src/sockserv.erl
@@ -0,0 +1,13 @@
+%%% Starting the sockserv application.
+%%% The sockserv application is a lightweight
+%%% Raw socket server that can be used with telnet
+%%% to follow updates on the process quest game.
+%%% The port is defined in the app's env
+-module(sockserv).
+-behaviour(application).
+-export([start/2, stop/1]).
+
+start(normal, []) ->
+    sockserv_sup:start_link().
+
+stop(_) -> ok.
diff --git a/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/src/sockserv_pq_events.erl b/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/src/sockserv_pq_events.erl
new file mode 100644
index 0000000..c3c6705
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/src/sockserv_pq_events.erl
@@ -0,0 +1,25 @@
+%%% Converts events from a player's event manager into a
+%%% cast sent to the sockserv socket gen_server.
+-module(sockserv_pq_events).
+-behaviour(gen_event).
+-export([init/1, handle_event/2, handle_call/2, handle_info/2,
+         terminate/2, code_change/3]).
+
+init(Parent) -> {ok, Parent}.
+
+handle_event(E, Pid) ->
+    gen_server:cast(Pid, E),
+    {ok, Pid}.
+
+handle_call(Req, Pid) ->
+    Pid ! Req,
+    {ok, ok, Pid}.
+
+handle_info(E, Pid) ->
+    Pid ! E,
+    {ok, Pid}.
+
+terminate(_, _) -> ok.
+
+code_change(_OldVsn, Pid, _Extra) ->
+    {ok, Pid}.
diff --git a/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/src/sockserv_serv.erl b/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/src/sockserv_serv.erl
new file mode 100644
index 0000000..cabc608
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/src/sockserv_serv.erl
@@ -0,0 +1,153 @@
+%%% Handles socket connections, and bridges a remote server
+%%% With a progressquest game.
+-module(sockserv_serv).
+-behaviour(gen_server).
+
+-record(state, {name, % player's name
+                next, % next step, used when initializing
+                socket}). % the current socket
+
+-export([start_link/1]).
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+         code_change/3, terminate/2]).
+
+-define(SOCK(Msg), {tcp, _Port, Msg}).
+-define(TIME, 800).
+-define(EXP, 50).
+
+%% The socket is passed in from sockserv_sup.
+%% It's a listen socket, as started by gen_tcp:listen/2.
+%%
+%% In Erlang, a TCP socket must be started as a listening socket first.
+%% The listening socket can then be used to listen for a connection,
+%% meant to be accepted. To do so, use gen_tcp:accept/1-2, as it is done
+%% later in this module.
+%%
+%% A single listen socket can be used by many processes, each accepting
+%% a communication. When a communication is accepted with accept/1-2,
+%% a new socket, called accept socket, is returned. This accept socket
+%% is the one that may be used to communicate with a client.
+start_link(Socket) ->
+    gen_server:start_link(?MODULE, Socket, []).
+
+init(Socket) ->
+    %% properly seeding the process
+    <<A:32, B:32, C:32>> = crypto:rand_bytes(12),
+    random:seed({A,B,C}),
+    %% Because accepting a connection is a blocking function call,
+    %% we can not do it in here. Forward to the server loop!
+    gen_server:cast(self(), accept),
+    {ok, #state{socket=Socket}}.
+
+handle_call(_E, _From, State) ->
+    {noreply, State}.
+
+%% Accepting a connection
+handle_cast(accept, S = #state{socket=ListenSocket}) ->
+    %% this is the socket acceptance mentioned earlier
+    {ok, AcceptSocket} = gen_tcp:accept(ListenSocket),
+    %% Remember that thou art dust, and to dust thou shalt return.
+    %% We want to always keep a given number of children in this app.
+    sockserv_sup:start_socket(), % a new acceptor is born, praise the lord
+    send(AcceptSocket, "What's your character's name?", []),
+    {noreply, S#state{socket=AcceptSocket, next=name}};
+%% The player has given us his name (in handle_info)
+%% so we now roll stats that might or might not satisfy
+%% said player.
+handle_cast(roll_stats, S = #state{socket=Socket}) ->
+    Roll = pq_stats:initial_roll(),
+    send(Socket,
+         "Stats for your character:~n"
+         "  Charisma: ~B~n"
+         "  Constitution: ~B~n"
+         "  Dexterity: ~B~n"
+         "  Intelligence: ~B~n"
+         "  Strength: ~B~n"
+         "  Wisdom: ~B~n~n"
+         "Do you agree to these? y/n~n",
+         [Points || {_Name, Points} <- lists:sort(Roll)]),
+    {noreply, S#state{next={stats, Roll}}};
+%% The player has accepted the stats! Start the game!
+handle_cast(stats_accepted, S = #state{name=Name, next={stats, Stats}}) ->
+    processquest:start_player(Name, [{stats,Stats},{time,?TIME},
+                                     {lvlexp, ?EXP}]),
+    processquest:subscribe(Name, sockserv_pq_events, self()),
+    {noreply, S#state{next=playing}};
+%% Events coming in from process quest
+%% We know this because all these events' tuples start with the
+%% name of the player.
+handle_cast(Event, S = #state{name=N, socket=Sock}) when element(1, Event) =:= N ->
+    [case E of
+       {wait, Time} -> timer:sleep(Time);
+       IoList -> send(Sock, IoList, [])
+     end || E <- sockserv_trans:to_str(Event)], % translate to a string
+    {noreply, S}.
+
+%% The TCP client sends the string "quit". We close the connection.
+handle_info(?SOCK("quit"++_), S) ->
+    processquest:stop_player(S#state.name),
+    {stop, normal, S};
+%% We receive a string while looking for a name -- we assume that hte
+%% string is the name.
+handle_info(?SOCK(Str), S = #state{next=name}) ->
+    Name = line(Str),
+    gen_server:cast(self(), roll_stats),
+    {noreply, S#state{name=Name, next=stats}};
+%% The user might or might not accept the stats we rolled in handle_cast
+handle_info(?SOCK(Str), S = #state{socket=Socket, next={stats, _}}) ->
+    case line(Str) of
+        "y" ->
+            gen_server:cast(self(), stats_accepted);
+        "n" ->
+            gen_server:cast(self(), roll_stats);
+        _ -> % ask again because we didn't get what we wanted
+            send(Socket, "Answer with y (yes) or n (no)", [])
+    end,
+    {noreply, S};
+handle_info(?SOCK(E), S = #state{socket=Socket}) ->
+    send(Socket, "Unexpected input: ~p~n", [E]),
+    {noreply, S};
+handle_info({tcp_closed, _Socket}, S) ->
+    {stop, normal, S};
+handle_info({tcp_error, _Socket, _}, S) ->
+    {stop, normal, S};
+handle_info(E, S) ->
+    io:format("unexpected: ~p~n", [E]),
+    {noreply, S}.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+terminate(normal, #state{socket=S}) ->
+    gen_tcp:close(S);
+terminate(_Reason, _State) ->
+    io:format("terminate reason: ~p~n", [_Reason]).
+
+%% Send a message through a socket, then make it active again.
+%% The difference between an active and a passive socket is that
+%% an active socket will send incoming data as Erlang messages, while
+%% passive sockets will require to be polled with gen_tcp:recv/2-3.
+%%
+%% Depending on the context, you might want one or the other. I chose
+%% to have active sockets because they feel somewhat easier to work
+%% with. However, one problem with active sockets is that all input
+%% is blindly changed into messages and makes it so the Erlang VM
+%% is somewhat more subject to overload. Passive sockets push this
+%% responsibility to the underlying implementation and the OS and are
+%% somewhat safer.
+%%
+%% A middle ground exists, with sockets that are 'active once'.
+%% The {active, once} option (can be set with inet:setopts or
+%% when creating the listen socket) makes it so only *one* message
+%% will be sent in active mode, and then the socket is automatically
+%% turned back to passive mode. On each message reception, we turn
+%% the socket back to {active once} as to achieve rate limiting.
+send(Socket, Str, Args) ->
+    ok = gen_tcp:send(Socket, io_lib:format(Str++"~n", Args)),
+    ok = inet:setopts(Socket, [{active, once}]),
+    ok.
+
+%% Let's get rid of the whitespace and ignore whatever's after.
+%% makes it simpler to deal with telnet.
+line(Str) ->
+    hd(string:tokens(Str, "\r\n ")).
diff --git a/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/src/sockserv_sup.erl b/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/src/sockserv_sup.erl
new file mode 100644
index 0000000..0e8cbdd
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/src/sockserv_sup.erl
@@ -0,0 +1,32 @@
+%%% The supervisor in charge of all the socket acceptors.
+-module(sockserv_sup).
+-behaviour(supervisor).
+
+-export([start_link/0, start_socket/0]).
+-export([init/1]).
+
+start_link() ->
+    supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
+init([]) ->
+    {ok, Port} = application:get_env(port),
+    %% Set the socket into {active_once} mode.
+    %% See sockserv_serv comments for more details
+    {ok, ListenSocket} = gen_tcp:listen(Port, [{active,once}, {packet,line}]),
+    spawn_link(fun empty_listeners/0),
+    {ok, {{simple_one_for_one, 60, 3600},
+         [{socket,
+          {sockserv_serv, start_link, [ListenSocket]}, % pass the socket!
+          temporary, 1000, worker, [sockserv_serv]}
+         ]}}.
+
+start_socket() ->
+    supervisor:start_child(?MODULE, []).
+
+%% Start with 20 listeners so that many multiple connections can
+%% be started at once, without serialization. In best circumstances,
+%% a process would keep the count active at all times to insure nothing
+%% bad happens over time when processes get killed too much.
+empty_listeners() ->
+    [start_socket() || _ <- lists:seq(1,20)],
+    ok.
diff --git a/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/src/sockserv_trans.erl b/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/src/sockserv_trans.erl
new file mode 100644
index 0000000..23a70c0
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/sockserv-1.0.0/src/sockserv_trans.erl
@@ -0,0 +1,58 @@
+%%% Translates the process quest events to iolists
+%%% that can be sent over a socket.
+%%%
+%%% IO lists are lists of bytes (0..255, ASCII),
+%%% binaries and other iolists. They allow to append,
+%%% prepend and insert data in strings without re-writing
+%%% the fragments that compose them. Erlang's drivers and
+%%% IO modules accept them without an issue and are a quick,
+%%% somewhat elegant solution to immutable data structures
+%%% requiring many changes.
+-module(sockserv_trans).
+-export([to_str/1]).
+
+%% The player killed something
+to_str({_User, killed, Time, {EnemyName, Props}}) ->
+    {Drop, _} = proplists:get_value(drop, Props),
+    [["Executing a ",EnemyName, "..."],
+     {wait, Time}, % take a pause between the output values
+     ["Obtained ", Drop, "."]];
+%% Changing locations
+to_str({_Name, heading, _Time, Loc}) ->
+    [["Heading to ",
+      case Loc of
+        market -> "the marketplace to sell loot...";
+        killing -> "the killing fields..."
+      end]];
+%% Leveling up
+to_str({_Name, lvl_up, _, NewStats, NewLvl, _NewExp}) ->
+    [["Leveled up to level ", integer_to_list(NewLvl),
+      " Here are your new stats:", $\n,
+      io_lib:format(
+         "  Charisma: ~B~n"
+         "  Constitution: ~B~n"
+         "  Dexterity: ~B~n"
+         "  Intelligence: ~B~n"
+         "  Strength: ~B~n"
+         "  Wisdom: ~B~n~n",
+         [Points || {_, Points} <- lists:sort(NewStats)])]];
+%% Bought an item
+to_str({_Name, buy, Time, Slot, {Item, _, _, _}}) ->
+    SlotTxt = case Slot of
+        armor -> " armor";
+        weapon -> "";
+        helmet -> " helmet";
+        shield -> " shield"
+    end,
+    [["Negotiating purchase of better equipment..."],
+     {wait, Time},
+     ["Bought a ", Item, SlotTxt]];
+%% Sold an item
+to_str({_Name, sell, Time, {Item, Val}}) ->
+    [["Selling ", Item],
+     {wait, Time},
+     ["Got ", integer_to_list(Val), " bucks."]];
+%% Completed a quest
+to_str({_Name, quest, 0, Completed, New}) ->
+    [["Completed quest: ", Completed, "..."],
+     ["Obtained new quest: ", New, "."]].
diff --git a/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/Emakefile b/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/Emakefile
new file mode 100644
index 0000000..b203ea3
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/Emakefile
@@ -0,0 +1,2 @@
+{["src/*", "test/*"],
+ [{i,"include"}, {outdir, "ebin"}]}.
diff --git a/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/ebin/sockserv.app b/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/ebin/sockserv.app
new file mode 100644
index 0000000..63618d0
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/ebin/sockserv.app
@@ -0,0 +1,11 @@
+{application, sockserv,
+ [{description, "Socket server to forward ProcessQuest messages to a client"},
+  {vsn, "1.0.1"},
+  {mod, {sockserv, []}},
+  {registered, [sockserv_sup]},
+  {modules, [sockserv, sockserv_sup, sockserv_serv, sockserv_trans,
+             sockserv_pq_events]},
+  {applications, [stdlib, kernel, processquest]},
+  {env,
+    [{port, 8082}]}
+ ]}.
diff --git a/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/ebin/sockserv.appup b/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/ebin/sockserv.appup
new file mode 100644
index 0000000..5462e65
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/ebin/sockserv.appup
@@ -0,0 +1,4 @@
+{"1.0.1",
+ [{"1.0.0", [{load_module, sockserv_serv}]}],
+ [{"1.0.0", [{load_module, sockserv_serv}]}]}.
+
diff --git a/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/src/sockserv.erl b/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/src/sockserv.erl
new file mode 100644
index 0000000..bd82b6d
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/src/sockserv.erl
@@ -0,0 +1,13 @@
+%%% Starting the sockserv application.
+%%% The sockserv application is a lightweight
+%%% Raw socket server that can be used with telnet
+%%% to follow updates on the process quest game.
+%%% The port is defined in the app's env
+-module(sockserv).
+-behaviour(application).
+-export([start/2, stop/1]).
+
+start(normal, []) ->
+    sockserv_sup:start_link().
+
+stop(_) -> ok.
diff --git a/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/src/sockserv_pq_events.erl b/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/src/sockserv_pq_events.erl
new file mode 100644
index 0000000..c3c6705
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/src/sockserv_pq_events.erl
@@ -0,0 +1,25 @@
+%%% Converts events from a player's event manager into a
+%%% cast sent to the sockserv socket gen_server.
+-module(sockserv_pq_events).
+-behaviour(gen_event).
+-export([init/1, handle_event/2, handle_call/2, handle_info/2,
+         terminate/2, code_change/3]).
+
+init(Parent) -> {ok, Parent}.
+
+handle_event(E, Pid) ->
+    gen_server:cast(Pid, E),
+    {ok, Pid}.
+
+handle_call(Req, Pid) ->
+    Pid ! Req,
+    {ok, ok, Pid}.
+
+handle_info(E, Pid) ->
+    Pid ! E,
+    {ok, Pid}.
+
+terminate(_, _) -> ok.
+
+code_change(_OldVsn, Pid, _Extra) ->
+    {ok, Pid}.
diff --git a/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/src/sockserv_serv.erl b/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/src/sockserv_serv.erl
new file mode 100644
index 0000000..24aed16
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/src/sockserv_serv.erl
@@ -0,0 +1,154 @@
+%%% Handles socket connections, and bridges a remote server
+%%% With a progressquest game.
+-module(sockserv_serv).
+-behaviour(gen_server).
+
+-record(state, {name, % player's name
+                next, % next step, used when initializing
+                socket}). % the current socket
+
+-export([start_link/1]).
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+         code_change/3, terminate/2]).
+
+-define(SOCK(Msg), {tcp, _Port, Msg}).
+-define(TIME, 800).
+-define(EXP, 50).
+
+%% The socket is passed in from sockserv_sup.
+%% It's a listen socket, as started by gen_tcp:listen/2.
+%%
+%% In Erlang, a TCP socket must be started as a listening socket first.
+%% The listening socket can then be used to listen for a connection,
+%% meant to be accepted. To do so, use gen_tcp:accept/1-2, as it is done
+%% later in this module.
+%%
+%% A single listen socket can be used by many processes, each accepting
+%% a communication. When a communication is accepted with accept/1-2,
+%% a new socket, called accept socket, is returned. This accept socket
+%% is the one that may be used to communicate with a client.
+start_link(Socket) ->
+    gen_server:start_link(?MODULE, Socket, []).
+
+init(Socket) ->
+    %% properly seeding the process
+    <<A:32, B:32, C:32>> = crypto:rand_bytes(12),
+    random:seed({A,B,C}),
+    %% Because accepting a connection is a blocking function call,
+    %% we can not do it in here. Forward to the server loop!
+    gen_server:cast(self(), accept),
+    {ok, #state{socket=Socket}}.
+
+handle_call(_E, _From, State) ->
+    {noreply, State}.
+
+%% Accepting a connection
+handle_cast(accept, S = #state{socket=ListenSocket}) ->
+    %% this is the socket acceptance mentioned earlier
+    {ok, AcceptSocket} = gen_tcp:accept(ListenSocket),
+    %% Remember that thou art dust, and to dust thou shalt return.
+    %% We want to always keep a given number of children in this app.
+    sockserv_sup:start_socket(), % a new acceptor is born, praise the lord
+    send(AcceptSocket, "What's your character's name?", []),
+    {noreply, S#state{socket=AcceptSocket, next=name}};
+%% The player has given us his name (in handle_info)
+%% so we now roll stats that might or might not satisfy
+%% said player.
+handle_cast(roll_stats, S = #state{socket=Socket}) ->
+    Roll = pq_stats:initial_roll(),
+    send(Socket,
+         "Stats for your character:~n"
+         "  Charisma: ~B~n"
+         "  Constitution: ~B~n"
+         "  Dexterity: ~B~n"
+         "  Intelligence: ~B~n"
+         "  Strength: ~B~n"
+         "  Wisdom: ~B~n~n"
+         "Do you agree to these? y/n~n",
+         [Points || {_Name, Points} <- lists:sort(Roll)]),
+    {noreply, S#state{next={stats, Roll}}};
+%% The player has accepted the stats! Start the game!
+handle_cast(stats_accepted, S = #state{name=Name, next={stats, Stats}}) ->
+    processquest:start_player(Name, [{stats,Stats},{time,?TIME},
+                                     {lvlexp, ?EXP}]),
+    processquest:subscribe(Name, sockserv_pq_events, self()),
+    {noreply, S#state{next=playing}};
+%% Events coming in from process quest
+%% We know this because all these events' tuples start with the
+%% name of the player.
+handle_cast(Event, S = #state{name=N, socket=Sock}) when element(1, Event) =:= N ->
+    [case E of
+       {wait, Time} -> timer:sleep(Time);
+       IoList -> send(Sock, IoList, [])
+     end || E <- sockserv_trans:to_str(Event)], % translate to a string
+    {noreply, S}.
+
+%% The TCP client sends the string "quit". We close the connection.
+handle_info(?SOCK("quit"++_), S) ->
+    processquest:stop_player(S#state.name),
+    gen_tcp:close(S#state.socket),
+    {stop, normal, S};
+%% We receive a string while looking for a name -- we assume that hte
+%% string is the name.
+handle_info(?SOCK(Str), S = #state{next=name}) ->
+    Name = line(Str),
+    gen_server:cast(self(), roll_stats),
+    {noreply, S#state{name=Name, next=stats}};
+%% The user might or might not accept the stats we rolled in handle_cast
+handle_info(?SOCK(Str), S = #state{socket=Socket, next={stats, _}}) ->
+    case line(Str) of
+        "y" ->
+            gen_server:cast(self(), stats_accepted);
+        "n" ->
+            gen_server:cast(self(), roll_stats);
+        _ -> % ask again because we didn't get what we wanted
+            send(Socket, "Answer with y (yes) or n (no)", [])
+    end,
+    {noreply, S};
+handle_info(?SOCK(E), S = #state{socket=Socket}) ->
+    send(Socket, "Unexpected input: ~p~n", [E]),
+    {noreply, S};
+handle_info({tcp_closed, _Socket}, S) ->
+    {stop, normal, S};
+handle_info({tcp_error, _Socket, _}, S) ->
+    {stop, normal, S};
+handle_info(E, S) ->
+    io:format("unexpected: ~p~n", [E]),
+    {noreply, S}.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+terminate(normal, _State) ->
+    ok;
+terminate(_Reason, _State) ->
+    io:format("terminate reason: ~p~n", [_Reason]).
+
+%% Send a message through a socket, then make it active again.
+%% The difference between an active and a passive socket is that
+%% an active socket will send incoming data as Erlang messages, while
+%% passive sockets will require to be polled with gen_tcp:recv/2-3.
+%%
+%% Depending on the context, you might want one or the other. I chose
+%% to have active sockets because they feel somewhat easier to work
+%% with. However, one problem with active sockets is that all input
+%% is blindly changed into messages and makes it so the Erlang VM
+%% is somewhat more subject to overload. Passive sockets push this
+%% responsibility to the underlying implementation and the OS and are
+%% somewhat safer.
+%%
+%% A middle ground exists, with sockets that are 'active once'.
+%% The {active, once} option (can be set with inet:setopts or
+%% when creating the listen socket) makes it so only *one* message
+%% will be sent in active mode, and then the socket is automatically
+%% turned back to passive mode. On each message reception, we turn
+%% the socket back to {active once} as to achieve rate limiting.
+send(Socket, Str, Args) ->
+    ok = gen_tcp:send(Socket, io_lib:format(Str++"~n", Args)),
+    ok = inet:setopts(Socket, [{active, once}]),
+    ok.
+
+%% Let's get rid of the whitespace and ignore whatever's after.
+%% makes it simpler to deal with telnet.
+line(Str) ->
+    hd(string:tokens(Str, "\r\n ")).
diff --git a/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/src/sockserv_sup.erl b/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/src/sockserv_sup.erl
new file mode 100644
index 0000000..0e8cbdd
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/src/sockserv_sup.erl
@@ -0,0 +1,32 @@
+%%% The supervisor in charge of all the socket acceptors.
+-module(sockserv_sup).
+-behaviour(supervisor).
+
+-export([start_link/0, start_socket/0]).
+-export([init/1]).
+
+start_link() ->
+    supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
+init([]) ->
+    {ok, Port} = application:get_env(port),
+    %% Set the socket into {active_once} mode.
+    %% See sockserv_serv comments for more details
+    {ok, ListenSocket} = gen_tcp:listen(Port, [{active,once}, {packet,line}]),
+    spawn_link(fun empty_listeners/0),
+    {ok, {{simple_one_for_one, 60, 3600},
+         [{socket,
+          {sockserv_serv, start_link, [ListenSocket]}, % pass the socket!
+          temporary, 1000, worker, [sockserv_serv]}
+         ]}}.
+
+start_socket() ->
+    supervisor:start_child(?MODULE, []).
+
+%% Start with 20 listeners so that many multiple connections can
+%% be started at once, without serialization. In best circumstances,
+%% a process would keep the count active at all times to insure nothing
+%% bad happens over time when processes get killed too much.
+empty_listeners() ->
+    [start_socket() || _ <- lists:seq(1,20)],
+    ok.
diff --git a/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/src/sockserv_trans.erl b/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/src/sockserv_trans.erl
new file mode 100644
index 0000000..23a70c0
--- /dev/null
+++ b/learn-you-some-erlang/processquest/apps/sockserv-1.0.1/src/sockserv_trans.erl
@@ -0,0 +1,58 @@
+%%% Translates the process quest events to iolists
+%%% that can be sent over a socket.
+%%%
+%%% IO lists are lists of bytes (0..255, ASCII),
+%%% binaries and other iolists. They allow to append,
+%%% prepend and insert data in strings without re-writing
+%%% the fragments that compose them. Erlang's drivers and
+%%% IO modules accept them without an issue and are a quick,
+%%% somewhat elegant solution to immutable data structures
+%%% requiring many changes.
+-module(sockserv_trans).
+-export([to_str/1]).
+
+%% The player killed something
+to_str({_User, killed, Time, {EnemyName, Props}}) ->
+    {Drop, _} = proplists:get_value(drop, Props),
+    [["Executing a ",EnemyName, "..."],
+     {wait, Time}, % take a pause between the output values
+     ["Obtained ", Drop, "."]];
+%% Changing locations
+to_str({_Name, heading, _Time, Loc}) ->
+    [["Heading to ",
+      case Loc of
+        market -> "the marketplace to sell loot...";
+        killing -> "the killing fields..."
+      end]];
+%% Leveling up
+to_str({_Name, lvl_up, _, NewStats, NewLvl, _NewExp}) ->
+    [["Leveled up to level ", integer_to_list(NewLvl),
+      " Here are your new stats:", $\n,
+      io_lib:format(
+         "  Charisma: ~B~n"
+         "  Constitution: ~B~n"
+         "  Dexterity: ~B~n"
+         "  Intelligence: ~B~n"
+         "  Strength: ~B~n"
+         "  Wisdom: ~B~n~n",
+         [Points || {_, Points} <- lists:sort(NewStats)])]];
+%% Bought an item
+to_str({_Name, buy, Time, Slot, {Item, _, _, _}}) ->
+    SlotTxt = case Slot of
+        armor -> " armor";
+        weapon -> "";
+        helmet -> " helmet";
+        shield -> " shield"
+    end,
+    [["Negotiating purchase of better equipment..."],
+     {wait, Time},
+     ["Bought a ", Item, SlotTxt]];
+%% Sold an item
+to_str({_Name, sell, Time, {Item, Val}}) ->
+    [["Selling ", Item],
+     {wait, Time},
+     ["Got ", integer_to_list(Val), " bucks."]];
+%% Completed a quest
+to_str({_Name, quest, 0, Completed, New}) ->
+    [["Completed quest: ", Completed, "..."],
+     ["Obtained new quest: ", New, "."]].
diff --git a/learn-you-some-erlang/processquest/processquest-1.0.0.config b/learn-you-some-erlang/processquest/processquest-1.0.0.config
new file mode 100644
index 0000000..2e62f5d
--- /dev/null
+++ b/learn-you-some-erlang/processquest/processquest-1.0.0.config
@@ -0,0 +1,21 @@
+{sys, [
+    {lib_dirs, ["/Users/ferd/code/learn-you-some-erlang/processquest/apps"]},
+    {erts, [{mod_cond, derived},
+            {app_file, strip}]},
+    {rel, "processquest", "1.0.0",
+     [kernel, stdlib, sasl, crypto, regis, sockserv, processquest]},
+    {boot_rel, "processquest"},
+    {relocatable, true},
+    {profile, embedded},
+    {app_file, strip},
+    {incl_cond, exclude},
+    {excl_app_filters, ["_tests.beam"]},
+    {excl_archive_filters, [".*"]},
+    {app, stdlib, [{incl_cond, include}]},
+    {app, kernel, [{incl_cond, include}]},
+    {app, sasl, [{incl_cond, include}]},
+    {app, crypto, [{incl_cond, include}]},
+    {app, regis, [{vsn, "1.0.0"}, {incl_cond, include}]},
+    {app, sockserv, [{vsn, "1.0.0"}, {incl_cond, include}]},
+    {app, processquest, [{vsn, "1.0.0"}, {incl_cond, include}]}
+]}.
diff --git a/learn-you-some-erlang/processquest/processquest-1.1.0.config b/learn-you-some-erlang/processquest/processquest-1.1.0.config
new file mode 100644
index 0000000..38a55f4
--- /dev/null
+++ b/learn-you-some-erlang/processquest/processquest-1.1.0.config
@@ -0,0 +1,21 @@
+{sys, [
+    {lib_dirs, ["/Users/ferd/code/learn-you-some-erlang/processquest/apps"]},
+    {erts, [{mod_cond, derived},
+            {app_file, strip}]},
+    {rel, "processquest", "1.1.0",
+     [kernel, stdlib, sasl, crypto, regis, processquest, sockserv]},
+    {boot_rel, "processquest"},
+    {relocatable, true},
+    {profile, embedded},
+    {app_file, strip},
+    {incl_cond, exclude},
+    {excl_app_filters, ["_tests.beam"]},
+    {excl_archive_filters, [".*"]},
+    {app, stdlib, [{incl_cond, include}]},
+    {app, kernel, [{incl_cond, include}]},
+    {app, sasl, [{incl_cond, include}]},
+    {app, crypto, [{incl_cond, include}]},
+    {app, regis, [{vsn, "1.0.0"}, {incl_cond, include}]},
+    {app, sockserv, [{vsn, "1.0.1"}, {incl_cond, include}]},
+    {app, processquest, [{vsn, "1.1.0"}, {incl_cond, include}]}
+]}.
diff --git a/learn-you-some-erlang/processquest/rel/.this-directory-must-be-tracked b/learn-you-some-erlang/processquest/rel/.this-directory-must-be-tracked
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/learn-you-some-erlang/processquest/rel/.this-directory-must-be-tracked
diff --git a/learn-you-some-erlang/records.erl b/learn-you-some-erlang/records.erl
new file mode 100644
index 0000000..f5a65b1
--- /dev/null
+++ b/learn-you-some-erlang/records.erl
@@ -0,0 +1,39 @@
+-module(records).
+-compile(export_all).
+-include("records.hrl").
+
+-record(robot, {name,
+                type=industrial,
+                hobbies,
+                details=[]}).
+-record(user, {id, name, group, age}).
+
+first_robot() ->
+    #robot{name="Mechatron",
+           type=handmade, 
+           details=["Moved by a small man inside"]}.
+
+car_factory(CorpName) ->
+    #robot{name=CorpName, hobbies="building cars"}.
+
+%% use pattern matching to filter
+admin_panel(#user{name=Name, group=admin}) ->
+    Name ++ " is allowed!";
+admin_panel(#user{name=Name}) ->
+    Name ++ " is not allowed".
+
+%% can extend user without problem
+adult_section(U = #user{}) when U#user.age >= 18 ->
+    %% Show stuff that can't be written in such a text
+    allowed;
+adult_section(_) ->
+    %% redirect to sesame street site
+    forbidden.
+
+repairman(Rob) ->
+    Details = Rob#robot.details,
+    NewRob = Rob#robot{details=["Repaired by repairman"|Details]},
+    {repaired, NewRob}.
+
+
+included() -> #included{some_field="Some value"}.
diff --git a/learn-you-some-erlang/records.hrl b/learn-you-some-erlang/records.hrl
new file mode 100644
index 0000000..c9a0eae
--- /dev/null
+++ b/learn-you-some-erlang/records.hrl
@@ -0,0 +1,4 @@
+%% this is a .hrl (header) file.
+-record(included, {some_field,
+                   some_default = "yeah!",
+                   unimaginative_name}).
diff --git a/learn-you-some-erlang/recursive.erl b/learn-you-some-erlang/recursive.erl
new file mode 100644
index 0000000..96a046c
--- /dev/null
+++ b/learn-you-some-erlang/recursive.erl
@@ -0,0 +1,135 @@
+-module(recursive).
+-export([fac/1, tail_fac/1, len/1, tail_len/1, duplicate/2,
+         tail_duplicate/2, reverse/1, tail_reverse/1, sublist/2, 
+         tail_sublist/2, zip/2, lenient_zip/2, tail_zip/2,
+         tail_lenient_zip/2]).
+-export([quicksort/1, lc_quicksort/1, bestest_qsort/1]).
+
+%% basic recursive factorial function
+fac(0) -> 1;
+fac(N) when N > 0 -> N*fac(N-1).
+
+%% tail recursive version of fac/1
+tail_fac(N) -> tail_fac(N,1).
+
+tail_fac(0,Acc) -> Acc;
+tail_fac(N,Acc) when N > 0 -> tail_fac(N-1,N*Acc).
+
+%% finds the len of a list
+len([]) -> 0;
+len([_|T]) -> 1 + len(T).
+
+%% tail recursive version of len/1
+tail_len(L) -> tail_len(L,0).
+
+tail_len([], Acc) -> Acc;
+tail_len([_|T], Acc) -> tail_len(T,Acc+1).
+
+%% duplicates Term N times
+duplicate(0,_) ->
+    [];
+duplicate(N,Term) when N > 0 ->
+    [Term|duplicate(N-1,Term)].
+
+%% tail recursive version of duplicate/2
+tail_duplicate(N,Term) ->
+    tail_duplicate(N,Term,[]).
+
+tail_duplicate(0,_,List) ->
+    List;
+tail_duplicate(N,Term,List) when N > 0 ->
+    tail_duplicate(N-1, Term, [Term|List]).
+
+%% reverses a list (a truly descriptive function name!)
+reverse([]) -> [];
+reverse([H|T]) -> reverse(T)++[H].
+
+
+%% tail recursive version of reverse/1
+tail_reverse(L) -> tail_reverse(L,[]).
+
+tail_reverse([],Acc) -> Acc;
+tail_reverse([H|T],Acc) -> tail_reverse(T, [H|Acc]).
+
+
+%% returns the N first elements of a list
+sublist(_,0) -> [];
+sublist([],_) -> [];
+sublist([H|T],N) when N > 0 -> [H|sublist(T,N-1)].
+
+%% tail recursive version of sublist/2
+tail_sublist(L, N) -> reverse(tail_sublist(L, N, [])).
+
+tail_sublist(_, 0, SubList) -> SubList;
+tail_sublist([], _, SubList) -> SubList;
+tail_sublist([H|T], N, SubList) when N > 0 ->
+    tail_sublist(T, N-1, [H|SubList]).
+
+%% Takes two lists [A] and [B] and returns a list of tuples
+%% with the form [{A,B}]. Both lists need to be of same lenght.
+zip([],[]) -> [];
+zip([X|Xs],[Y|Ys]) -> [{X,Y}|zip(Xs,Ys)].
+
+%% Same as zip/2, but lists can vary in lenght
+lenient_zip([],_) -> [];
+lenient_zip(_,[]) -> [];
+lenient_zip([X|Xs],[Y|Ys]) -> [{X,Y}|lenient_zip(Xs,Ys)].
+
+%% tail recursive version of zip/2
+tail_zip(X,Y) -> reverse(tail_zip(X,Y,[])).
+
+tail_zip([],[],Acc) -> Acc;
+tail_zip([X|Xs],[Y|Ys], Acc) ->
+    tail_zip(Xs,Ys, [{X,Y}|Acc]).
+
+%% tail recursive version of lenient-zip/2
+tail_lenient_zip(X,Y) -> reverse(tail_lenient_zip(X,Y,[])).
+
+tail_lenient_zip([],_,Acc) -> Acc;
+tail_lenient_zip(_,[],Acc) -> Acc;
+tail_lenient_zip([X|Xs],[Y|Ys], Acc) ->
+    tail_lenient_zip(Xs,Ys,[{X,Y}|Acc]).
+
+%% basic quicksort function.
+quicksort([]) -> [];
+quicksort([Pivot|Rest]) ->
+    {Smaller, Larger} = partition(Pivot,Rest,[],[]),
+    quicksort(Smaller) ++ [Pivot] ++ quicksort(Larger).
+
+partition(_,[], Smaller, Larger) -> {Smaller, Larger};
+partition(Pivot, [H|T], Smaller, Larger) ->
+    if H =< Pivot -> partition(Pivot, T, [H|Smaller], Larger);
+       H >  Pivot -> partition(Pivot, T, Smaller, [H|Larger])
+    end. 
+
+%% quicksort built with list comprehensions rather than with a
+%% partition function.
+lc_quicksort([]) -> [];
+lc_quicksort([Pivot|Rest]) ->
+    lc_quicksort([Smaller || Smaller <- Rest, Smaller =< Pivot])
+    ++ [Pivot] ++
+    lc_quicksort([Larger || Larger <- Rest, Larger > Pivot]).
+
+%% BESTEST QUICKSORT, YEAH!
+%% (This is not really the bestest quicksort, because we do not do
+%%  adequate pivot selection. It is the bestest of this book, alright?
+%%  Thanks to literateprograms.org for this example. Give them a visit!
+%%  http://en.literateprograms.org/Quicksort_(Erlang) )
+bestest_qsort([]) -> [];
+bestest_qsort(L=[_|_]) ->
+    bestest_qsort(L, []).
+
+bestest_qsort([], Acc) -> Acc;
+bestest_qsort([Pivot|Rest], Acc) ->
+    bestest_partition(Pivot, Rest, {[], [Pivot], []}, Acc).
+
+bestest_partition(_, [], {Smaller, Equal, Larger}, Acc) ->
+    bestest_qsort(Smaller, Equal ++ bestest_qsort(Larger, Acc));
+bestest_partition(Pivot, [H|T], {Smaller, Equal, Larger}, Acc) ->
+    if H < Pivot ->
+           bestest_partition(Pivot, T, {[H|Smaller], Equal, Larger}, Acc);
+       H > Pivot ->
+           bestest_partition(Pivot, T, {Smaller, Equal, [H|Larger]}, Acc);
+       H == Pivot ->
+           bestest_partition(Pivot, T, {Smaller, [H|Equal], Larger}, Acc)
+    end.
diff --git a/learn-you-some-erlang/release/erlcount-1.0.config b/learn-you-some-erlang/release/erlcount-1.0.config
new file mode 100644
index 0000000..235ab23
--- /dev/null
+++ b/learn-you-some-erlang/release/erlcount-1.0.config
@@ -0,0 +1,20 @@
+{sys, [
+    {lib_dirs, ["/home/ferd/code/learn-you-some-erlang/release/"]},
+    {erts, [{vsn, "5.8.4"}]},
+    {rel, "erlcount", "1.0.0",
+     [kernel,
+      stdlib,
+      {ppool, permanent},
+      {erlcount, transient}
+     ]},
+    {boot_rel, "erlcount"},
+    {relocatable, true},
+    {profile, embedded},
+    {app, ppool, [{vsn, "1.0.0"},
+                  {app_file, all},
+                  {debug_info, keep}]},
+    {app, erlcount, [{vsn, "1.0.0"},
+                     {incl_cond, include},
+                     {app_file, strip},
+                     {debug_info, strip}]}
+]}.
diff --git a/learn-you-some-erlang/release/erlcount-1.0.rel b/learn-you-some-erlang/release/erlcount-1.0.rel
new file mode 100644
index 0000000..aa2ce44
--- /dev/null
+++ b/learn-you-some-erlang/release/erlcount-1.0.rel
@@ -0,0 +1,7 @@
+{release,
+ {"erlcount", "1.0.0"},
+ {erts, "5.8.4"},
+ [{kernel, "2.14.4"},
+  {stdlib, "1.17.4"},
+  {ppool, "1.0.0", permanent},
+  {erlcount, "1.0.0", transient}]}.
diff --git a/learn-you-some-erlang/release/erlcount-1.0/Emakefile b/learn-you-some-erlang/release/erlcount-1.0/Emakefile
new file mode 100644
index 0000000..76e98fc
--- /dev/null
+++ b/learn-you-some-erlang/release/erlcount-1.0/Emakefile
@@ -0,0 +1,4 @@
+{"src/*", [debug_info, {i,"include/"}, {outdir, "ebin/"}]}.
+%% The TESTDIR macro assumes the file is running from the 'erlcount-1.0'
+%% directory, sitting within 'learn-you-some-erlang/'.
+{"test/*", [debug_info, {i,"include/"}, {outdir, "ebin/"}, {d, 'TESTDIR', ".."}]}.
diff --git a/learn-you-some-erlang/release/erlcount-1.0/ebin/erlcount.app b/learn-you-some-erlang/release/erlcount-1.0/ebin/erlcount.app
new file mode 100644
index 0000000..22f0f0a
--- /dev/null
+++ b/learn-you-some-erlang/release/erlcount-1.0/ebin/erlcount.app
@@ -0,0 +1,14 @@
+{application, erlcount,
+ [{vsn, "1.0.0"},
+  {description, "Run regular expressions on Erlang source files"},
+  {modules, [erlcount, erlcount_sup, erlcount_lib,
+             erlcount_dispatch, erlcount_counter]},
+  {applications, [stdlib, kernel, ppool]},
+  {registered, [erlcount]},
+  {mod, {erlcount, []}},
+  {env,
+   [{directory, "."},
+    {regex, ["if\\s.+->", "case\\s.+\\sof"]},
+    {max_files, 10}]}
+ ]}.
+
diff --git a/learn-you-some-erlang/release/erlcount-1.0/src/erlcount.erl b/learn-you-some-erlang/release/erlcount-1.0/src/erlcount.erl
new file mode 100644
index 0000000..16a9f23
--- /dev/null
+++ b/learn-you-some-erlang/release/erlcount-1.0/src/erlcount.erl
@@ -0,0 +1,9 @@
+-module(erlcount).
+-behaviour(application).
+-export([start/2, stop/1]).
+
+start(normal, _Args) ->
+    erlcount_sup:start_link().
+
+stop(_State) ->
+    ok.
diff --git a/learn-you-some-erlang/release/erlcount-1.0/src/erlcount_counter.erl b/learn-you-some-erlang/release/erlcount-1.0/src/erlcount_counter.erl
new file mode 100644
index 0000000..c42fd4d
--- /dev/null
+++ b/learn-you-some-erlang/release/erlcount-1.0/src/erlcount_counter.erl
@@ -0,0 +1,35 @@
+-module(erlcount_counter).
+-behaviour(gen_server).
+-export([start_link/4]).
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+        terminate/2, code_change/3]).
+
+-record(state, {dispatcher, ref, file, re}).
+
+start_link(DispatcherPid, Ref, FileName, Regex) ->
+    gen_server:start_link(?MODULE, [DispatcherPid, Ref, FileName, Regex], []).
+
+init([DispatcherPid, Ref, FileName, Regex]) ->
+    self() ! start,
+    {ok, #state{dispatcher=DispatcherPid,
+                ref = Ref,
+                file = FileName,
+                re = Regex}}.
+
+handle_call(_Msg, _From, State) ->
+    {noreply, State}.
+
+handle_cast(_Msg, State) ->
+    {noreply, State}.
+
+handle_info(start, S = #state{re=Re, ref=Ref}) ->
+    {ok, Bin} = file:read_file(S#state.file),
+    Count = erlcount_lib:regex_count(Re, Bin),
+    erlcount_dispatch:complete(S#state.dispatcher, Re, Ref, Count),
+    {stop, normal, S}.
+
+terminate(_Reason, _State) ->
+    ok.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
diff --git a/learn-you-some-erlang/release/erlcount-1.0/src/erlcount_dispatch.erl b/learn-you-some-erlang/release/erlcount-1.0/src/erlcount_dispatch.erl
new file mode 100644
index 0000000..c125da3
--- /dev/null
+++ b/learn-you-some-erlang/release/erlcount-1.0/src/erlcount_dispatch.erl
@@ -0,0 +1,86 @@
+-module(erlcount_dispatch).
+-behaviour(gen_fsm).
+-export([start_link/0, complete/4]).
+-export([init/1, dispatching/2, listening/2, handle_event/3,
+        handle_sync_event/4, handle_info/3, terminate/3, code_change/4]).
+
+-define(POOL, erlcount).
+-record(data, {regex=[], refs=[]}).
+
+%%% PUBLIC API
+start_link() ->
+    gen_fsm:start_link(?MODULE, [], []).
+
+complete(Pid, Regex, Ref, Count) ->
+    gen_fsm:send_all_state_event(Pid, {complete, Regex, Ref, Count}).
+
+%%% GEN_FSM
+%% Two states: dispatching and listening
+init([]) ->
+    %% Move the get_env stuff to the supervisor's init.
+    {ok, Re} = application:get_env(regex),
+    {ok, Dir} = application:get_env(directory),
+    {ok, MaxFiles} = application:get_env(max_files),
+    ppool:start_pool(?POOL, MaxFiles, {erlcount_counter, start_link, []}),
+    case lists:all(fun valid_regex/1, Re) of
+        true ->
+            %% creates a regex entry of the form [{Re, Count}]
+            self() ! {start, Dir},
+            {ok, dispatching, #data{regex=[{R,0} || R <- Re]}};
+        false ->
+           {stop, invalid_regex}
+    end.
+
+dispatching({continue, File, Continuation}, Data = #data{regex=Re, refs=Refs}) ->
+    F = fun({Regex,_Count}, NewRefs) ->
+        Ref = make_ref(),
+        ppool:async_queue(?POOL, [self(), Ref, File, Regex]),
+        [Ref|NewRefs]
+    end,
+    NewRefs = lists:foldl(F, Refs, Re),
+    gen_fsm:send_event(self(), Continuation()),
+    {next_state, dispatching, Data#data{refs = NewRefs}};
+dispatching(done, Data) ->
+    %% This is a special case. We can not assume that all messages have NOT
+    %% been received by the time we hit 'done'. As such, we directly move to
+    %% listening/2 without waiting for an external event.
+    listening(done, Data).
+
+listening(done, #data{regex=Re, refs=[]}) -> % all received!
+    [io:format("Regex ~s has ~p results~n", [R,C]) || {R, C} <- Re],
+    {stop, normal, done};
+listening(done, Data) -> % entries still missing
+    {next_state, listening, Data}.
+
+handle_event({complete, Regex, Ref, Count}, State, Data = #data{regex=Re, refs=Refs}) ->
+    {Regex, OldCount} = lists:keyfind(Regex, 1, Re),
+    NewRe = lists:keyreplace(Regex, 1, Re, {Regex, OldCount+Count}),
+    NewData = Data#data{regex=NewRe, refs=Refs--[Ref]},
+    case State of
+        dispatching ->
+            {next_state, dispatching, NewData};
+        listening ->
+            listening(done, NewData)
+    end.
+
+handle_sync_event(Event, _From, State, Data) ->
+    io:format("Unexpected event: ~p~n", [Event]),
+    {next_state, State, Data}.
+
+handle_info({start, Dir}, State, Data) ->
+    gen_fsm:send_event(self(), erlcount_lib:find_erl(Dir)),
+    {next_state, State, Data}.
+
+terminate(_Reason, _State, _Data) ->
+    init:stop().
+
+code_change(_OldVsn, State, Data, _Extra) ->
+    {ok, State, Data}.
+
+%%% PRIVATE 
+valid_regex(Re) ->
+    try re:run("", Re) of
+        _ -> true
+    catch
+        error:badarg -> false
+    end.
diff --git a/learn-you-some-erlang/release/erlcount-1.0/src/erlcount_lib.erl b/learn-you-some-erlang/release/erlcount-1.0/src/erlcount_lib.erl
new file mode 100644
index 0000000..70c062f
--- /dev/null
+++ b/learn-you-some-erlang/release/erlcount-1.0/src/erlcount_lib.erl
@@ -0,0 +1,55 @@
+-module(erlcount_lib).
+-export([find_erl/1, regex_count/2]).
+-include_lib("kernel/include/file.hrl").
+
+%% Finds all files ending in .erl
+find_erl(Directory) ->
+    find_erl(Directory, queue:new()).
+
+regex_count(Re, Str) ->
+    case re:run(Str, Re, [global]) of
+        nomatch -> 0;
+        {match, List} -> length(List)
+    end.
+
+%%% Private
+%% Dispatches based on file type
+find_erl(Name, Queue) ->
+    {ok, F = #file_info{}} = file:read_file_info(Name),
+    case F#file_info.type of
+        directory -> handle_directory(Name, Queue);
+        regular -> handle_regular_file(Name, Queue);
+        _Other -> dequeue_and_run(Queue)
+    end.
+
+%% Opens directories and enqueues files in there
+handle_directory(Dir, Queue) ->
+    case file:list_dir(Dir) of
+        {ok, []} ->
+            dequeue_and_run(Queue);
+        {ok, Files} ->
+            dequeue_and_run(enqueue_many(Dir, Files, Queue))
+    end.
+
+%% Checks if the file finishes in .erl
+handle_regular_file(Name, Queue) ->
+    case filename:extension(Name) of
+        ".erl" ->
+            {continue, Name, fun() -> dequeue_and_run(Queue) end};
+        _NonErl ->
+            dequeue_and_run(Queue)
+    end.
+
+%% Pops an item from the queue and runs it.
+dequeue_and_run(Queue) ->
+    case queue:out(Queue) of
+        {empty, _} -> done;
+        {{value, File}, NewQueue} -> find_erl(File, NewQueue)
+    end.
+
+%% Adds a bunch of items to the queue.
+enqueue_many(Path, Files, Queue) ->
+    F = fun(File, Q) -> queue:in(filename:join(Path,File), Q) end,
+    lists:foldl(F, Queue, Files).
+
+
diff --git a/learn-you-some-erlang/release/erlcount-1.0/src/erlcount_sup.erl b/learn-you-some-erlang/release/erlcount-1.0/src/erlcount_sup.erl
new file mode 100644
index 0000000..b8633a3
--- /dev/null
+++ b/learn-you-some-erlang/release/erlcount-1.0/src/erlcount_sup.erl
@@ -0,0 +1,17 @@
+-module(erlcount_sup).
+-behaviour(supervisor).
+-export([start_link/0, init/1]).
+
+start_link() ->
+    supervisor:start_link(?MODULE, []).
+
+init([]) ->
+    MaxRestart = 5,
+    MaxTime = 100,
+    {ok, {{one_for_one, MaxRestart, MaxTime},
+     [{dispatch,
+       {erlcount_dispatch, start_link, []},
+        transient,
+        60000,
+        worker,
+        [erlcount_dispatch]}]}}.
diff --git a/learn-you-some-erlang/release/erlcount-1.0/test/erlcount_tests.erl b/learn-you-some-erlang/release/erlcount-1.0/test/erlcount_tests.erl
new file mode 100644
index 0000000..7459a39
--- /dev/null
+++ b/learn-you-some-erlang/release/erlcount-1.0/test/erlcount_tests.erl
@@ -0,0 +1,35 @@
+-module(erlcount_tests).
+-include_lib("eunit/include/eunit.hrl").
+-ifndef(TESTDIR).
+%% Assumes we're running from the app's directory. We want to target the
+%% 'learn-you-some-erlang' directory.
+-define(TESTDIR, "..").
+-endif.
+
+%% NOTE:
+%% Because we do not want the tests to be bound to a specific snapshot in time
+%% of our app, we will instead compare it to an oracle built with unix
+%% commands. Users running windows sadly won't be able to run these tests.
+
+%% We'll be forcing the design to be continuation-based when it comes to
+%% reading files. This will require some explaining to the user, but will
+%% allow to show how we can read files and schedule them at the same time,
+%% but without breaking functional principles of referential transparency
+%% and while allowing specialised functions to be written in a testable manner.
+find_erl_test_() ->
+    ?_assertEqual(lists:sort(string:tokens(os:cmd("find "++?TESTDIR++" -name *.erl"), "\n")),
+        lists:sort(build_list(erlcount_lib:find_erl(?TESTDIR)))).
+
+build_list(Term) -> build_list(Term, []).
+
+build_list(done, List) -> List;
+build_list({continue, Entry, Fun}, List) ->
+    build_list(Fun(), [Entry|List]).
+
+regex_count_test_() ->
+    [?_assertEqual(5, erlcount_lib:regex_count("a", "a a a a a")),
+     ?_assertEqual(0, erlcount_lib:regex_count("o", "a a a a a")),
+     ?_assertEqual(2, erlcount_lib:regex_count("a.*", "a a a\na a a")),
+     ?_assertEqual(3, erlcount_lib:regex_count("if", "myiffun() ->\n if 1 < \" if \" -> ok;\n    true -> other\n end.\n")),
+     ?_assertEqual(1, erlcount_lib:regex_count("if[\\s]{1}(?:.+)->", "myiffun() ->\n if 1 < \" if  \" -> ok;\n    true -> other\n end.\n")),
+     ?_assertEqual(2, erlcount_lib:regex_count("if[\\s]{1}(?:.+)->", "myiffun() ->\n if 1 < \" if  \" -> ok;\n    true -> other\n end,\n if true -> ok end.\n"))].
diff --git a/learn-you-some-erlang/release/erlcount-sm.config b/learn-you-some-erlang/release/erlcount-sm.config
new file mode 100644
index 0000000..6e22bf1
--- /dev/null
+++ b/learn-you-some-erlang/release/erlcount-sm.config
@@ -0,0 +1,17 @@
+{sys, [
+    {lib_dirs, ["/home/ferd/code/learn-you-some-erlang/release/"]},
+    {erts, [{mod_cond, derived},
+            {app_file, strip}]},
+    {rel, "erlcount", "1.0.0", [kernel, stdlib, ppool, erlcount]},
+    {boot_rel, "erlcount"},
+    {relocatable, true},
+    {profile, embedded},
+    {app_file, strip},
+    {debug_info, strip},
+    {incl_cond, exclude},
+    {excl_app_filters, ["_tests.beam"]},
+    {app, stdlib, [{incl_cond, include}]},
+    {app, kernel, [{incl_cond, include}]},
+    {app, ppool, [{vsn, "1.0.0"}, {incl_cond, include}]},
+    {app, erlcount, [{vsn, "1.0.0"}, {incl_cond, include}]}
+]}.
diff --git a/learn-you-some-erlang/release/ppool-1.0/Emakefile b/learn-you-some-erlang/release/ppool-1.0/Emakefile
new file mode 100644
index 0000000..8e1f951
--- /dev/null
+++ b/learn-you-some-erlang/release/ppool-1.0/Emakefile
@@ -0,0 +1,2 @@
+{"src/*", [debug_info, {i,"include/"}, {outdir, "ebin/"}]}.
+{"test/*", [debug_info, {i,"include/"}, {outdir, "ebin/"}]}.
diff --git a/learn-you-some-erlang/release/ppool-1.0/ebin/ppool.app b/learn-you-some-erlang/release/ppool-1.0/ebin/ppool.app
new file mode 100644
index 0000000..f806b7c
--- /dev/null
+++ b/learn-you-some-erlang/release/ppool-1.0/ebin/ppool.app
@@ -0,0 +1,8 @@
+{application, ppool,
+ [{vsn, "1.0.0"},
+  {description, "Run and enqueue different concurrent tasks"},
+  {modules, [ppool, ppool_serv, ppool_sup, ppool_supersup, ppool_worker_sup]},
+  {applications, [stdlib, kernel]},
+  {registered, [ppool]},
+  {mod, {ppool, []}}
+ ]}.
diff --git a/learn-you-some-erlang/release/ppool-1.0/src/ppool.erl b/learn-you-some-erlang/release/ppool-1.0/src/ppool.erl
new file mode 100644
index 0000000..5723f98
--- /dev/null
+++ b/learn-you-some-erlang/release/ppool-1.0/src/ppool.erl
@@ -0,0 +1,26 @@
+%%% API module for the pool
+-module(ppool).
+-behaviour(application).
+-export([start/2, stop/1, start_pool/3,
+         run/2, sync_queue/2, async_queue/2, stop_pool/1]).
+
+start(normal, _Args) ->
+    ppool_supersup:start_link().
+
+stop(_State) ->
+    ok.
+
+start_pool(Name, Limit, {M,F,A}) ->
+    ppool_supersup:start_pool(Name, Limit, {M,F,A}).
+
+stop_pool(Name) ->
+    ppool_supersup:stop_pool(Name).
+
+run(Name, Args) ->
+    ppool_serv:run(Name, Args).
+
+async_queue(Name, Args) ->
+    ppool_serv:async_queue(Name, Args).
+
+sync_queue(Name, Args) ->
+    ppool_serv:sync_queue(Name, Args).
diff --git a/learn-you-some-erlang/release/ppool-1.0/src/ppool_serv.erl b/learn-you-some-erlang/release/ppool-1.0/src/ppool_serv.erl
new file mode 100644
index 0000000..bfb9b93
--- /dev/null
+++ b/learn-you-some-erlang/release/ppool-1.0/src/ppool_serv.erl
@@ -0,0 +1,113 @@
+-module(ppool_serv).
+-behaviour(gen_server).
+-export([start/4, start_link/4, run/2, sync_queue/2, async_queue/2, stop/1]).
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+         code_change/3, terminate/2]).
+
+%% The friendly supervisor is started dynamically!
+-define(SPEC(MFA),
+        {worker_sup,
+         {ppool_worker_sup, start_link, [MFA]},
+          temporary,
+          10000,
+          supervisor,
+          [ppool_worker_sup]}).
+
+-record(state, {limit=0,
+                sup,
+                refs,
+                queue=queue:new()}).
+
+start(Name, Limit, Sup, MFA) when is_atom(Name), is_integer(Limit) ->
+    gen_server:start({local, Name}, ?MODULE, {Limit, MFA, Sup}, []).
+
+start_link(Name, Limit, Sup, MFA) when is_atom(Name), is_integer(Limit) ->
+    gen_server:start_link({local, Name}, ?MODULE, {Limit, MFA, Sup}, []).
+
+run(Name, Args) ->
+    gen_server:call(Name, {run, Args}).
+
+sync_queue(Name, Args) ->
+    gen_server:call(Name, {sync, Args}, infinity).
+
+async_queue(Name, Args) ->
+    gen_server:cast(Name, {async, Args}).
+
+stop(Name) ->
+    gen_server:call(Name, stop).
+
+%% Gen server
+init({Limit, MFA, Sup}) ->
+    %% We need to find the Pid of the worker supervisor from here,
+    %% but alas, this would be calling the supervisor while it waits for us!
+    self() ! {start_worker_supervisor, Sup, MFA},
+    {ok, #state{limit=Limit, refs=gb_sets:empty()}}.
+
+handle_call({run, Args}, _From, S = #state{limit=N, sup=Sup, refs=R}) when N > 0 ->
+    {ok, Pid} = supervisor:start_child(Sup, Args),
+    Ref = erlang:monitor(process, Pid),
+    {reply, {ok,Pid}, S#state{limit=N-1, refs=gb_sets:add(Ref,R)}};
+handle_call({run, _Args}, _From, S=#state{limit=N}) when N =< 0 ->
+    {reply, noalloc, S};
+
+handle_call({sync, Args}, _From, S = #state{limit=N, sup=Sup, refs=R}) when N > 0 ->
+    {ok, Pid} = supervisor:start_child(Sup, Args),
+    Ref = erlang:monitor(process, Pid),
+    {reply, {ok,Pid}, S#state{limit=N-1, refs=gb_sets:add(Ref,R)}};
+handle_call({sync, Args},  From, S = #state{queue=Q}) ->
+    {noreply, S#state{queue=queue:in({From, Args}, Q)}};
+
+handle_call(stop, _From, State) ->
+    {stop, normal, ok, State};
+handle_call(_Msg, _From, State) ->
+    {noreply, State}.
+
+
+handle_cast({async, Args}, S=#state{limit=N, sup=Sup, refs=R}) when N > 0 ->
+    {ok, Pid} = supervisor:start_child(Sup, Args),
+    Ref = erlang:monitor(process, Pid),
+    {noreply, S#state{limit=N-1, refs=gb_sets:add(Ref,R)}};
+handle_cast({async, Args}, S=#state{limit=N, queue=Q}) when N =< 0 ->
+    {noreply, S#state{queue=queue:in(Args,Q)}};
+
+handle_cast(_Msg, State) ->
+    {noreply, State}.
+
+handle_info({'DOWN', Ref, process, _Pid, _}, S = #state{refs=Refs}) ->
+%%    io:format("received down msg~n"),
+    case gb_sets:is_element(Ref, Refs) of
+        true ->
+            handle_down_worker(Ref, S);
+        false -> %% Not our responsibility
+            {noreply, S}
+    end;
+handle_info({start_worker_supervisor, Sup, MFA}, S = #state{}) ->
+    {ok, Pid} = supervisor:start_child(Sup, ?SPEC(MFA)),
+    link(Pid),
+    {noreply, S#state{sup=Pid}};
+handle_info(Msg, State) ->
+    io:format("Unknown msg: ~p~n", [Msg]),
+    {noreply, State}.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+terminate(_Reason, _State) ->
+    ok.
+
+handle_down_worker(Ref, S = #state{limit=L, sup=Sup, refs=Refs}) ->
+    case queue:out(S#state.queue) of
+        {{value, {From, Args}}, Q} ->
+            {ok, Pid} = supervisor:start_child(Sup, Args),
+            NewRef = erlang:monitor(process, Pid),
+            NewRefs = gb_sets:insert(NewRef, gb_sets:delete(Ref,Refs)),
+            gen_server:reply(From, {ok, Pid}),
+            {noreply, S#state{refs=NewRefs, queue=Q}};
+        {{value, Args}, Q} ->
+            {ok, Pid} = supervisor:start_child(Sup, Args),
+            NewRef = erlang:monitor(process, Pid),
+            NewRefs = gb_sets:insert(NewRef, gb_sets:delete(Ref,Refs)),
+            {noreply, S#state{refs=NewRefs, queue=Q}};
+        {empty, _} ->
+            {noreply, S#state{limit=L+1, refs=gb_sets:delete(Ref,Refs)}}
+    end.
diff --git a/learn-you-some-erlang/release/ppool-1.0/src/ppool_sup.erl b/learn-you-some-erlang/release/ppool-1.0/src/ppool_sup.erl
new file mode 100644
index 0000000..71ec31d
--- /dev/null
+++ b/learn-you-some-erlang/release/ppool-1.0/src/ppool_sup.erl
@@ -0,0 +1,17 @@
+-module(ppool_sup).
+-export([start_link/3, init/1]).
+-behaviour(supervisor).
+
+start_link(Name, Limit, MFA) ->
+    supervisor:start_link(?MODULE, {Name, Limit, MFA}).
+
+init({Name, Limit, MFA}) ->
+    MaxRestart = 1,
+    MaxTime = 3000,
+    {ok, {{one_for_all, MaxRestart, MaxTime},
+          [{serv,
+             {ppool_serv, start_link, [Name, Limit, self(), MFA]},
+             permanent,
+             5000, 
+             worker,
+             [ppool_serv]}]}}.
diff --git a/learn-you-some-erlang/release/ppool-1.0/src/ppool_supersup.erl b/learn-you-some-erlang/release/ppool-1.0/src/ppool_supersup.erl
new file mode 100644
index 0000000..06fa0af
--- /dev/null
+++ b/learn-you-some-erlang/release/ppool-1.0/src/ppool_supersup.erl
@@ -0,0 +1,22 @@
+-module(ppool_supersup).
+-behaviour(supervisor).
+-export([start_link/0, start_pool/3, stop_pool/1]).
+-export([init/1]).
+
+start_link() ->
+    supervisor:start_link({local, ppool}, ?MODULE, []).
+
+start_pool(Name, Limit, MFA) ->
+    ChildSpec = {Name,
+                 {ppool_sup, start_link, [Name, Limit, MFA]},
+                  permanent, 10500, supervisor, [ppool_sup]},
+    supervisor:start_child(ppool, ChildSpec).
+
+stop_pool(Name) ->
+    supervisor:terminate_child(ppool, Name),
+    supervisor:delete_child(ppool, Name).
+
+init([]) ->
+    MaxRestart = 6,
+    MaxTime = 3000,
+    {ok, {{one_for_one, MaxRestart, MaxTime}, []}}.
diff --git a/learn-you-some-erlang/release/ppool-1.0/src/ppool_worker_sup.erl b/learn-you-some-erlang/release/ppool-1.0/src/ppool_worker_sup.erl
new file mode 100644
index 0000000..2467c47
--- /dev/null
+++ b/learn-you-some-erlang/release/ppool-1.0/src/ppool_worker_sup.erl
@@ -0,0 +1,15 @@
+-module(ppool_worker_sup).
+-export([start_link/1, init/1]).
+-behaviour(supervisor).
+
+start_link(MFA = {_,_,_}) ->
+    supervisor:start_link(?MODULE, MFA).
+
+init({M,F,A}) ->
+    MaxRestart = 5,
+    MaxTime = 3600,
+    {ok, {{simple_one_for_one, MaxRestart, MaxTime},
+          [{ppool_worker,
+            {M,F,A},
+            temporary, 5000, worker, [M]}]}}.
+    
diff --git a/learn-you-some-erlang/release/ppool-1.0/test/ppool_nagger.erl b/learn-you-some-erlang/release/ppool-1.0/test/ppool_nagger.erl
new file mode 100644
index 0000000..903f821
--- /dev/null
+++ b/learn-you-some-erlang/release/ppool-1.0/test/ppool_nagger.erl
@@ -0,0 +1,50 @@
+%% demo module, a nagger for tasks,
+%% because the previous one wasn't good enough
+%%
+%% Can take:
+%% - a time delay for which to nag,
+%% - an adress to say where the messages should be sent
+%% - a message to send in the mailbox telling you what to nag,
+%%   with an id to be able to call: ->
+%% - a command to say the task is done 
+-module(ppool_nagger).
+-behaviour(gen_server).
+-export([start_link/4, stop/1]).
+-export([init/1, handle_call/3, handle_cast/2,
+         handle_info/2, code_change/3, terminate/2]).
+
+start_link(Task, Delay, Max, SendTo) ->
+    gen_server:start_link(?MODULE, {Task, Delay, Max, SendTo} , []).
+
+stop(Pid) ->
+    gen_server:call(Pid, stop).
+
+init({Task, Delay, Max, SendTo}) ->
+    process_flag(trap_exit, true), % for tests & terminate too
+    {ok, {Task, Delay, Max, SendTo}, Delay}.
+
+%%% OTP Callbacks
+handle_call(stop, _From, State) ->
+    {stop, normal, ok, State};
+handle_call(_Msg, _From, State) ->
+    {noreply, State}.
+
+handle_cast(_Msg, State) ->
+    {noreply, State}.
+
+handle_info(timeout, {Task, Delay, Max, SendTo}) ->
+    SendTo ! {self(), Task},
+    if Max =:= infinity ->
+        {noreply, {Task, Delay, Max, SendTo}, Delay};
+       Max =< 1 ->
+        {stop, normal, {Task, Delay, 0, SendTo}};
+       Max > 1  ->
+        {noreply, {Task, Delay, Max-1, SendTo}, Delay}
+    end;
+handle_info(_Msg, State) ->
+    {noreply, State}.
+
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+terminate(_Reason, _State) -> ok.
diff --git a/learn-you-some-erlang/release/ppool-1.0/test/ppool_tests.erl b/learn-you-some-erlang/release/ppool-1.0/test/ppool_tests.erl
new file mode 100644
index 0000000..8f0dfe2
--- /dev/null
+++ b/learn-you-some-erlang/release/ppool-1.0/test/ppool_tests.erl
@@ -0,0 +1,200 @@
+-module(ppool_tests).
+-include_lib("eunit/include/eunit.hrl").
+-export([test_mfa/1, wait_mfa/1]).
+
+%%% All Test Fixtures
+start_test_() ->
+    {"It should be possible to start a pool server and give it a name",
+     {setup,
+      fun find_unique_name/0,
+      fun(Name) ->
+        [start_and_test_name(Name)]
+      end}}.
+
+mfa_test_() ->
+    {"A pool process can be allocated which will be ordered "
+     "to run an MFA call determined at start time, with arguments "
+     "provided at call time",
+     {setup,
+      fun start_ppool/0,
+      fun kill_ppool/1,
+      fun(Name) ->
+        [pool_run_mfa(Name)]
+      end}
+    }.
+
+alloc_test_() ->
+    {"A pool process can be allocated which will be ordered "
+     "to run a worker, only if there are enough which "
+     "haven't been ordered to run yet.",
+     {setup,
+      fun start_ppool/0,
+      fun kill_ppool/1,
+      fun(Name) ->
+        [pool_run_alloc(Name),
+         pool_run_noalloc(Name)]
+      end}
+    }.
+
+realloc_test_() ->
+    {"When an allocated process dies, "
+     "A new one can be allocated to replace it.",
+     {setup,
+      fun start_ppool/0,
+      fun kill_ppool/1,
+      fun(Name) ->
+        [pool_run_realloc(Name)]
+      end}
+    }.
+
+queue_test_() ->
+    {"The queue function can be used to run the function as soon as possible. "
+     "If no space is available, the worker call is added to the queue.",
+     {foreach,
+      fun start_ppool/0,
+      fun kill_ppool/1,
+      [fun(Name) -> test_async_queue(Name) end,
+       fun(Name) -> test_sync_queue(Name) end]}
+    }.
+
+supervision_test_() ->
+    {"The ppool will never restart a dead child, but all children (OTP "
+     "compliant) will be shut down when closing the pool, even if they "
+     "are trapping exits",
+     {setup,
+      fun find_unique_name/0,
+      fun test_supervision/1}}.
+    
+auth_test_() ->
+    {"The ppool should only dequeue tasks after receiving a down signal "
+     "from a worker and nobody else",
+     {setup,
+      fun start_ppool/0,
+      fun kill_ppool/1,
+      fun test_auth_dealloc/1}}.
+
+%%% Setups/teardowns
+find_unique_name() ->
+    application:start(ppool),
+    Name = list_to_atom(lists:flatten(io_lib:format("~p",[now()]))),
+    ?assertEqual(undefined, whereis(Name)),
+    Name.
+
+start_ppool() ->
+    Name = find_unique_name(),
+    ppool:start_pool(Name, 2, {ppool_nagger, start_link, []}),
+    Name.
+
+kill_ppool(Name) ->
+    ppool:stop_pool(Name).
+    
+%%% Actual tests
+start_and_test_name(Name) ->
+    ppool:start_pool(Name, 1, {ppool_nagger, start_link, []}),
+    A = whereis(Name),
+    ppool:stop_pool(Name),
+    timer:sleep(100),
+    B = whereis(Name),
+    [?_assert(undefined =/= A),
+     ?_assertEqual(undefined, B)].
+
+pool_run_mfa(Name) ->
+    ppool:run(Name, [i_am_running, 1, 1, self()]),
+    X = receive
+        {_Pid, i_am_running} -> ok
+    after 3000 ->
+        timeout
+    end,
+    ?_assertEqual(ok, X).
+
+pool_run_alloc(Name) ->
+    {ok, Pid} = ppool:run(Name, [i_am_running, 1, 1, self()]),
+    X = receive
+        {Pid, i_am_running} -> ok
+    after 3000 ->
+        timeout
+    end,
+    [?_assert(is_pid(Pid)),
+     ?_assertEqual(ok, X)].
+
+pool_run_noalloc(Name) ->
+    %% Init function should have set the limit to 2
+    ppool:run(Name, [i_am_running, 300, 1, self()]),
+    ppool:run(Name, [i_am_running, 300, 1, self()]),
+    X = ppool:run(Name, [i_am_running, 1, 1, self()]),
+    ?_assertEqual(noalloc, X).
+    
+pool_run_realloc(Name) ->
+    %% Init function should have set the limit to 2
+    {ok, A} = ppool:run(Name, [i_am_running, 500, 1, self()]),
+    timer:sleep(100),
+    {ok, B} = ppool:run(Name, [i_am_running, 500, 1, self()]),
+    timer:sleep(600),
+    {ok, Pid} = ppool:run(Name, [i_am_running, 1, 1, self()]),
+    timer:sleep(100),
+    L = flush(),
+    [?_assert(is_pid(Pid)),
+     ?_assertEqual([{A,i_am_running}, {B,i_am_running}, {Pid,i_am_running}],
+                   L)].
+
+test_async_queue(Name) ->
+    %% Still two elements max!
+    ok = ppool:async_queue(Name, [i_am_running, 2000, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 2000, 1, self()]),
+    noalloc = ppool:run(Name, [i_am_running, 2000, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 500, 1, self()]),
+    timer:sleep(3500),
+    L = flush(),
+    ?_assertMatch([{_, i_am_running}, {_, i_am_running}, {_, i_am_running}], L).
+
+test_sync_queue(Name) ->
+    %% Hell yase, two max
+    {ok, Pid} = ppool:sync_queue(Name, [i_am_running, 200, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 200, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 200, 1, self()]),
+    {ok, Pid2} = ppool:sync_queue(Name, [i_am_running, 100, 1, self()]),
+    timer:sleep(300),
+    L = flush(),
+    [?_assert(is_pid(Pid)),
+     ?_assert(is_pid(Pid2)),
+     ?_assertMatch([{_,i_am_running}, {_,i_am_running},
+                    {_,i_am_running}, {_,i_am_running}],
+                   L)].
+
+test_supervision(Name) ->
+    ppool:start_pool(Name, 1, {ppool_nagger, start_link, []}),
+    {ok, Pid} = ppool:run(Name, [sup, 10000, 100, self()]),
+    ppool:stop_pool(Name),
+    timer:sleep(100),
+    ?_assertEqual(undefined, process_info(Pid)). 
+
+test_auth_dealloc(Name) ->
+    %% Hell yase, two max
+    {ok, _Pid} = ppool:sync_queue(Name, [i_am_running, 500, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 10000, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 10000, 1, self()]),
+    ok = ppool:async_queue(Name, [i_am_running, 1, 1, self()]),
+    timer:sleep(600),
+    Name ! {'DOWN', make_ref(), process, self(), normal},
+    Name ! {'DOWN', make_ref(), process, self(), normal},
+    Name ! {'DOWN', make_ref(), process, self(), normal},
+    timer:sleep(200),
+    L = flush(),
+    ?_assertMatch([{_,i_am_running}], L).
+    
+
+
+flush() ->
+    receive
+        X -> [X|flush()]
+    after 0 ->
+        []
+    end.
+
+%% Exported Helper functions
+test_mfa(Pid) ->
+    Pid ! i_am_running.
+
+wait_mfa(Pid) ->
+    Pid ! i_am_running,
+    timer:sleep(3000).
diff --git a/learn-you-some-erlang/release/rel/.this-file-intentionally-left-blank b/learn-you-some-erlang/release/rel/.this-file-intentionally-left-blank
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/learn-you-some-erlang/release/rel/.this-file-intentionally-left-blank
diff --git a/learn-you-some-erlang/reminder/Emakefile b/learn-you-some-erlang/reminder/Emakefile
new file mode 100644
index 0000000..fbde9cb
--- /dev/null
+++ b/learn-you-some-erlang/reminder/Emakefile
@@ -0,0 +1,4 @@
+{'src/*', [debug_info,
+           {i, "src"},
+           {i, "include"},
+           {outdir, "ebin"}]}.
diff --git a/learn-you-some-erlang/reminder/ebin/.this-file-intentionally-left-blank b/learn-you-some-erlang/reminder/ebin/.this-file-intentionally-left-blank
new file mode 100644
index 0000000..758f532
--- /dev/null
+++ b/learn-you-some-erlang/reminder/ebin/.this-file-intentionally-left-blank
@@ -0,0 +1 @@
+Thank you, Mercurial! I still love you...
diff --git a/learn-you-some-erlang/reminder/include/.this-file-intentionally-left-blank b/learn-you-some-erlang/reminder/include/.this-file-intentionally-left-blank
new file mode 100644
index 0000000..758f532
--- /dev/null
+++ b/learn-you-some-erlang/reminder/include/.this-file-intentionally-left-blank
@@ -0,0 +1 @@
+Thank you, Mercurial! I still love you...
diff --git a/learn-you-some-erlang/reminder/priv/.this-file-intentionally-left-blank b/learn-you-some-erlang/reminder/priv/.this-file-intentionally-left-blank
new file mode 100644
index 0000000..758f532
--- /dev/null
+++ b/learn-you-some-erlang/reminder/priv/.this-file-intentionally-left-blank
@@ -0,0 +1 @@
+Thank you, Mercurial! I still love you...
diff --git a/learn-you-some-erlang/reminder/src/.this-file-intentionally-left-blank b/learn-you-some-erlang/reminder/src/.this-file-intentionally-left-blank
new file mode 100644
index 0000000..758f532
--- /dev/null
+++ b/learn-you-some-erlang/reminder/src/.this-file-intentionally-left-blank
@@ -0,0 +1 @@
+Thank you, Mercurial! I still love you...
diff --git a/learn-you-some-erlang/reminder/src/dev_event.erl b/learn-you-some-erlang/reminder/src/dev_event.erl
new file mode 100644
index 0000000..5b752ac
--- /dev/null
+++ b/learn-you-some-erlang/reminder/src/dev_event.erl
@@ -0,0 +1,82 @@
+%%% This module is there to test the incomplete loops and constructs
+%%% that are presented in the text, but are not the final result.
+-module(dev_event).
+-compile(export_all).
+-record(state, {server,
+                name="",
+                to_go=0}).
+
+start1(EventName, Delay) ->
+    spawn(?MODULE, init1, [self(), EventName, Delay]).
+
+start_link1(EventName, Delay) ->
+    spawn_link(?MODULE, init1, [self(), EventName, Delay]).
+
+start2(EventName, Delay) ->
+    spawn(?MODULE, init2, [self(), EventName, Delay]).
+
+start_link2(EventName, Delay) ->
+    spawn_link(?MODULE, init2, [self(), EventName, Delay]).
+
+cancel(Pid) ->
+    %% Monitor in case the process is already dead
+    Ref = erlang:monitor(process, Pid),
+    Pid ! {self(), Ref, cancel},
+    receive
+        {Ref, ok} ->
+            erlang:demonitor(Ref, [flush]),
+            ok;
+        {'DOWN', Ref, process, Pid, _Reason} ->
+            ok
+    end.
+
+
+
+%%% Event's innards
+init1(Server, EventName, Delay) ->
+    loop2(#state{server=Server,
+                name=EventName,
+                to_go=normalize(Delay)}).
+
+init2(Server, EventName, DateTime) ->
+    loop2(#state{server=Server,
+                name=EventName,
+                to_go=time_to_go(DateTime)}).
+
+loop1(S = #state{server=Server}) ->
+    receive
+        {Server, Ref, cancel} ->
+            Server ! {Ref, ok}
+    after S#state.to_go * 1000 ->
+        Server ! {done, S#state.name}
+    end.
+
+%% Loop uses a list for times in order to go around the ~49 days limit
+%% on timeouts.
+loop2(S = #state{server=Server, to_go=[T|Next]}) ->
+    receive
+        {Server, Ref, cancel} ->
+            Server ! {Ref, ok}
+    after T*1000 ->
+        if Next =:= [] ->
+            Server ! {done, S#state.name};
+           Next =/= [] ->
+            loop2(S#state{to_go=Next})
+        end
+    end.
+
+
+time_to_go(TimeOut={{_,_,_}, {_,_,_}}) ->
+    Now = calendar:local_time(),
+    ToGo = calendar:datetime_to_gregorian_seconds(TimeOut) -
+           calendar:datetime_to_gregorian_seconds(Now),
+    Secs = if ToGo > 0  -> ToGo;
+              ToGo =< 0 -> 0
+           end,
+    normalize(Secs).
+
+%% Because Erlang is limited to about 49 days (49*24*60*60*1000) in
+%% milliseconds, the following function is used
+normalize(N) ->
+    Limit = 49*24*60*60,
+    [N rem Limit | lists:duplicate(N div Limit, Limit)].
diff --git a/learn-you-some-erlang/reminder/src/event.erl b/learn-you-some-erlang/reminder/src/event.erl
new file mode 100644
index 0000000..58b5b57
--- /dev/null
+++ b/learn-you-some-erlang/reminder/src/event.erl
@@ -0,0 +1,61 @@
+-module(event).
+-export([start/2, start_link/2, cancel/1]).
+-export([init/3, loop/1]).
+-record(state, {server,
+                name="",
+                to_go=0}).
+
+%%% Public interface
+start(EventName, DateTime) ->
+    spawn(?MODULE, init, [self(), EventName, DateTime]).
+
+start_link(EventName, DateTime) ->
+    spawn_link(?MODULE, init, [self(), EventName, DateTime]).
+
+cancel(Pid) ->
+    %% Monitor in case the process is already dead
+    Ref = erlang:monitor(process, Pid),
+    Pid ! {self(), Ref, cancel},
+    receive
+        {Ref, ok} ->
+            erlang:demonitor(Ref, [flush]),
+            ok;
+        {'DOWN', Ref, process, Pid, _Reason} ->
+            ok
+    end.
+
+%%% Event's innards
+init(Server, EventName, DateTime) ->
+    loop(#state{server=Server,
+                name=EventName,
+                to_go=time_to_go(DateTime)}).
+
+%% Loop uses a list for times in order to go around the ~49 days limit
+%% on timeouts.
+loop(S = #state{server=Server, to_go=[T|Next]}) ->
+    receive
+        {Server, Ref, cancel} ->
+            Server ! {Ref, ok}
+    after T*1000 ->
+        if Next =:= [] ->
+            Server ! {done, S#state.name};
+           Next =/= [] ->
+            loop(S#state{to_go=Next})
+        end
+    end.
+
+%%% private functions
+time_to_go(TimeOut={{_,_,_}, {_,_,_}}) ->
+    Now = calendar:local_time(),
+    ToGo = calendar:datetime_to_gregorian_seconds(TimeOut) -
+           calendar:datetime_to_gregorian_seconds(Now),
+    Secs = if ToGo > 0  -> ToGo;
+              ToGo =< 0 -> 0
+           end,
+    normalize(Secs).
+
+%% Because Erlang is limited to about 49 days (49*24*60*60*1000) in
+%% milliseconds, the following function is used
+normalize(N) ->
+    Limit = 49*24*60*60,
+    [N rem Limit | lists:duplicate(N div Limit, Limit)].
diff --git a/learn-you-some-erlang/reminder/src/evserv.erl b/learn-you-some-erlang/reminder/src/evserv.erl
new file mode 100644
index 0000000..1087376
--- /dev/null
+++ b/learn-you-some-erlang/reminder/src/evserv.erl
@@ -0,0 +1,168 @@
+%% Event server
+-module(evserv).
+-compile(export_all).
+
+-record(state, {events,    %% list of #event{} records
+                clients}). %% list of Pids
+
+-record(event, {name="",
+                description="",
+                pid,
+                timeout={{1970,1,1},{0,0,0}}}).
+
+%%% User Interface
+
+start() ->
+    register(?MODULE, Pid=spawn(?MODULE, init, [])),
+    Pid.
+
+start_link() ->
+    register(?MODULE, Pid=spawn_link(?MODULE, init, [])),
+    Pid.
+
+terminate() ->
+    ?MODULE ! shutdown.
+
+init() ->
+    %% Loading events from a static file could be done here.
+    %% You would need to pass an argument to init (maybe change the functions
+    %% start/0 and start_link/0 to start/1 and start_link/1) telling where the
+    %% resource to find the events is. Then load it from here.
+    %% Another option is to just pass the event straight to the server
+    %% through this function.
+    loop(#state{events=orddict:new(),
+                clients=orddict:new()}).
+
+subscribe(Pid) ->
+    Ref = erlang:monitor(process, whereis(?MODULE)),
+    ?MODULE ! {self(), Ref, {subscribe, Pid}},
+    receive
+        {Ref, ok} ->
+            {ok, Ref};
+        {'DOWN', Ref, process, _Pid, Reason} ->
+            {error, Reason}
+    after 5000 ->
+        {error, timeout}
+    end.
+
+add_event(Name, Description, TimeOut) ->
+    Ref = make_ref(),
+    ?MODULE ! {self(), Ref, {add, Name, Description, TimeOut}},
+    receive
+        {Ref, Msg} -> Msg
+    after 5000 ->
+        {error, timeout}
+    end.
+
+add_event2(Name, Description, TimeOut) ->
+    Ref = make_ref(),
+    ?MODULE ! {self(), Ref, {add, Name, Description, TimeOut}},
+    receive
+        {Ref, {error, Reason}} -> erlang:error(Reason);
+        {Ref, Msg} -> Msg
+    after 5000 ->
+        {error, timeout}
+    end.
+
+cancel(Name) ->
+    Ref = make_ref(),
+    ?MODULE ! {self(), Ref, {cancel, Name}},
+    receive
+        {Ref, ok} -> ok
+    after 5000 ->
+        {error, timeout}
+    end.
+
+listen(Delay) ->
+    receive
+        M = {done, _Name, _Description} ->
+            [M | listen(0)]
+    after Delay*1000 ->
+        []
+    end.
+
+%%% The Server itself
+
+loop(S=#state{}) ->
+    receive
+        {Pid, MsgRef, {subscribe, Client}} ->
+            Ref = erlang:monitor(process, Client),
+            NewClients = orddict:store(Ref, Client, S#state.clients),
+            Pid ! {MsgRef, ok},
+            loop(S#state{clients=NewClients});
+        {Pid, MsgRef, {add, Name, Description, TimeOut}} ->
+            case valid_datetime(TimeOut) of
+                true ->
+                    EventPid = event:start_link(Name, TimeOut),
+                    NewEvents = orddict:store(Name,
+                                              #event{name=Name,
+                                                     description=Description,
+                                                     pid=EventPid,
+                                                     timeout=TimeOut},
+                                              S#state.events),
+                    Pid ! {MsgRef, ok},
+                    loop(S#state{events=NewEvents});
+                false ->
+                    Pid ! {MsgRef, {error, bad_timeout}},
+                    loop(S)
+            end;
+        {Pid, MsgRef, {cancel, Name}} ->
+            Events = case orddict:find(Name, S#state.events) of
+                         {ok, E} ->
+                             event:cancel(E#event.pid),
+                             orddict:erase(Name, S#state.events);
+                         error ->
+                             S#state.events
+                     end,
+            Pid ! {MsgRef, ok},
+            loop(S#state{events=Events});
+        {done, Name} ->
+            case orddict:find(Name, S#state.events) of
+                {ok, E} ->
+                    send_to_clients({done, E#event.name, E#event.description},
+                                    S#state.clients),
+                    NewEvents = orddict:erase(Name, S#state.events),
+                    loop(S#state{events=NewEvents});
+                error ->
+                    %% This may happen if we cancel an event and
+                    %% it fires at the same time
+                    loop(S)
+            end;
+        shutdown ->
+            exit(shutdown);
+        {'DOWN', Ref, process, _Pid, _Reason} ->
+            loop(S#state{clients=orddict:erase(Ref, S#state.clients)});
+        code_change ->
+            ?MODULE:loop(S);
+        {Pid, debug} -> %% used as a hack to let me do some unit testing
+            Pid ! S,
+            loop(S);
+        Unknown ->
+            io:format("Unknown message: ~p~n",[Unknown]),
+            loop(S)
+    end.
+
+
+%%% Internal Functions
+send_to_clients(Msg, ClientDict) ->
+    orddict:map(fun(_Ref, Pid) -> Pid ! Msg end, ClientDict).
+
+valid_datetime({Date,Time}) ->
+    try
+        calendar:valid_date(Date) andalso valid_time(Time)
+    catch
+        error:function_clause -> %% not in {{Y,M,D},{H,Min,S}} format
+            false
+    end;
+valid_datetime(_) ->
+    false.
+
+%% calendar has valid_date, but nothing for days.
+%% This function is based on its interface.
+%% Ugly, but ugh.
+valid_time({H,M,S}) -> valid_time(H,M,S).
+
+valid_time(H,M,S) when H >= 0, H < 24,
+                       M >= 0, M < 60,
+                       S >= 0, S < 60 -> true;
+valid_time(_,_,_) -> false.
diff --git a/learn-you-some-erlang/reminder/src/sup.erl b/learn-you-some-erlang/reminder/src/sup.erl
new file mode 100644
index 0000000..71a463b
--- /dev/null
+++ b/learn-you-some-erlang/reminder/src/sup.erl
@@ -0,0 +1,22 @@
+-module(sup).
+-export([start/2, start_link/2, init/1, loop/1]).
+
+start(Mod, Args) ->
+    spawn(?MODULE, init, [{Mod, Args}]).
+
+start_link(Mod,Args) ->
+    spawn_link(?MODULE, init, [{Mod, Args}]).
+
+init({Mod,Args}) ->
+    process_flag(trap_exit, true),
+    loop({Mod,start_link,Args}).
+
+loop({M,F,A}) ->
+    Pid = apply(M,F,A),
+    receive
+        {'EXIT', _From, shutdown} ->
+            exit(shutdown); % will kill the child too
+        {'EXIT', Pid, Reason} ->
+            io:format("Process ~p exited for reason ~p~n",[Pid,Reason]),
+            loop({M,F,A})
+    end.
diff --git a/learn-you-some-erlang/reminder/src/tests/dev_event_tests.erl b/learn-you-some-erlang/reminder/src/tests/dev_event_tests.erl
new file mode 100644
index 0000000..5de18d1
--- /dev/null
+++ b/learn-you-some-erlang/reminder/src/tests/dev_event_tests.erl
@@ -0,0 +1,41 @@
+-module(dev_event_tests).
+-include_lib("eunit/include/eunit.hrl").
+%%% Very minimal tests, only verifying that the two implementations of
+%%% timeouts work the same in their final and primitive versions
+%%% as in the final module. The rest is rather cruft to emulate the normal
+%%% event.erl module. Little is tested, because little needs to be tested.
+
+
+-record(state, {server,
+                name="",
+                to_go=[0]}).
+
+timeout_test_() ->
+    {inorder,
+     [fun() -> timeout(loop1, 2) end,
+      fun() -> timeout(loop2, [2]) end]}.
+
+timeout(AtomFun, T) ->
+    S = self(),
+    spawn_link(dev_event, AtomFun, [#state{server=S, name="test", to_go=T}]),
+    timer:sleep(1000),
+    M1 = receive A -> A after 0 -> timeout end,
+    timer:sleep(1500),
+    M2 = receive B -> B after 0 -> timeout end,
+    M3 = receive C -> C after 0 -> timeout end,
+    ?assertEqual(timeout, M1),
+    ?assertEqual({done, "test"}, M2),
+    ?assertEqual(timeout, M3).
+
+cancel_msg_test_() ->
+    {inorder, 
+     [fun() -> cancel_msg(loop1, 2) end,
+      fun() -> cancel_msg(loop2, [2]) end]}.
+
+cancel_msg(AtomFun, T) ->
+    S = self(),
+    R = make_ref(),
+    Pid = spawn_link(dev_event, AtomFun, [#state{server=S, name="test", to_go=T}]),
+    Pid ! {S, R, cancel},
+    M = receive A -> A after 500 -> timeout end,
+    ?assertEqual({R, ok}, M).
diff --git a/learn-you-some-erlang/reminder/src/tests/event_tests.erl b/learn-you-some-erlang/reminder/src/tests/event_tests.erl
new file mode 100644
index 0000000..80b3a44
--- /dev/null
+++ b/learn-you-some-erlang/reminder/src/tests/event_tests.erl
@@ -0,0 +1,43 @@
+-module(event_tests).
+-include_lib("eunit/include/eunit.hrl").
+-test_warnings([start/0, start_link/1, init/0, time_to_go/1]).
+%% defined in event.erl
+-record(state, {server,
+                name="",
+                to_go=[0]}).
+
+timeout_test_() ->
+    S = self(),
+    spawn_link(event, loop, [#state{server=S, name="test", to_go=[2]}]),
+    timer:sleep(1000),
+    M1 = receive A -> A after 0 -> timeout end,
+    timer:sleep(1500),
+    M2 = receive B -> B after 0 -> timeout end,
+    M3 = receive C -> C after 0 -> timeout end,
+    [?_assertEqual(timeout, M1),
+     ?_assertEqual({done, "test"}, M2),
+     ?_assertEqual(timeout, M3)].
+
+cancel_msg_test_() ->
+    S = self(),
+    R = make_ref(),
+    Pid = spawn_link(event, loop, [#state{server=S, name="test", to_go=[2]}]),
+    Pid ! {S, R, cancel},
+    M = receive A -> A after 500 -> timeout end,
+    [?_assertEqual({R, ok}, M)].
+
+cancel_fn_test_() ->
+    S = self(),
+    Pid = spawn_link(event, loop, [#state{server=S, name="test", to_go=[2]}]),
+    [?_assertEqual(ok, event:cancel(Pid)),
+     %% calling cancel again should fail, but still return ok.
+     ?_assertEqual(ok, event:cancel(Pid))].
+
+normalize_test_() ->
+    [?_assertEqual([0], event:normalize(0)),
+     ?_assertEqual([2], event:normalize(2)),
+     %% special cases w/ remainders
+     ?_assertEqual(1, length(event:normalize(49*24*60*59))),
+     ?_assertEqual(2, length(event:normalize(49*24*60*60))),
+     ?_assertEqual(2, length(event:normalize(49*24*60*60+1))),
+     ?_assertEqual(1000*24*60*60, lists:sum(event:normalize(1000*24*60*60)))].
diff --git a/learn-you-some-erlang/reminder/src/tests/evserv_tests.erl b/learn-you-some-erlang/reminder/src/tests/evserv_tests.erl
new file mode 100644
index 0000000..b093a58
--- /dev/null
+++ b/learn-you-some-erlang/reminder/src/tests/evserv_tests.erl
@@ -0,0 +1,203 @@
+-module(evserv_tests).
+-include_lib("eunit/include/eunit.hrl").
+-define(FUTURE_DATE, {{2100,1,1},{0,0,0}}).
+%% all the tests in this module would be much easier with property-based testing.
+%% see Triq, Quvic Quickcheck or Proper for libraries to download that let you
+%% do this.
+-test_warnings([start/0]).
+
+valid_time_test_() ->
+    [?_assert(evserv:valid_time({0,0,0})),
+     ?_assert(evserv:valid_time({23,59,59})),
+     ?_assert(not evserv:valid_time({23,59,60})),
+     ?_assert(not evserv:valid_time({23,60,59})),
+     ?_assert(not evserv:valid_time({24,59,59})),
+     ?_assert(not evserv:valid_time({-1,0,0})),
+     ?_assert(not evserv:valid_time({0,-1,0})),
+     ?_assert(not evserv:valid_time({0,0,-1}))].
+
+valid_datetime_test_() ->
+    [?_assert(evserv:valid_datetime({{0,1,1},{0,0,0}})),
+     ?_assert(evserv:valid_datetime({{2004,2,29},{23,59,59}})),
+     ?_assert(evserv:valid_datetime({{2004,12,31},{23,59,59}})),
+     ?_assert(not evserv:valid_datetime({{2004,12,31},{23,60,60}})),
+     ?_assert(not evserv:valid_datetime({{2003,2,29},{23,59,59}})),
+     ?_assert(not evserv:valid_datetime({{0,0,0},{0,0,0}})),
+     ?_assert(not evserv:valid_datetime(1209312303))].
+
+loop_test_() ->
+    {"Testing all server events on a protocol level",
+     [{"Subscribe Tests",
+       [{spawn,
+         {setup,
+          fun evserv:start_link/0,
+          fun terminate/1,
+          fun subscribe/1}},
+        {spawn,
+         {setup,
+          fun evserv:start_link/0,
+          fun terminate/1,
+          fun subscribe2/1}},
+        {spawn,
+         {setup,
+          fun evserv:start_link/0,
+          fun terminate/1,
+          fun down/1}}]},
+      {"Adding event integration tests",
+       [{spawn,
+         {setup,
+          fun evserv:start_link/0,
+          fun terminate/1,
+          fun add/1}},
+        {spawn,
+         {setup,
+          fun evserv:start_link/0,
+          fun terminate/1,
+          fun addremove/1}},
+        {spawn,
+         {setup,
+          fun evserv:start_link/0,
+          fun terminate/1,
+          fun done/1}}]}]}.
+
+interface_test_() ->
+    {"Testing all server events via the interface functions",
+     [{spawn,
+       {setup,
+        fun evserv:start_link/0,
+        fun terminate/1,
+        fun interface/1}}]}.
+
+subscribe(Pid) ->
+    Ref = make_ref(),
+    S = self(),
+    Pid ! {S, Ref, {subscribe, S}},
+    {ok, M1} = read(),
+    Pid ! {S, debug},
+    {ok, M2} = read(),
+    [?_assertEqual({Ref, ok}, M1),
+     ?_assertMatch({state,[], [{_, S}]}, M2)].
+
+subscribe2(Pid) ->
+    Ref1 = make_ref(),
+    Ref2 = make_ref(),
+    S = self(),
+    Pid ! {S, Ref1, {subscribe, S}},
+    {ok, M1} = read(),
+    Pid ! {S, Ref2, {subscribe, S}},
+    {ok, M2} = read(),
+    Pid ! {S, debug},
+    {ok, M3} = read(),
+    [?_assertEqual({Ref1, ok}, M1),
+     ?_assertEqual({Ref2, ok}, M2),
+     ?_assertMatch({state,[], [{_,S},{_,S}]}, M3)].
+
+down(Pid) ->
+    Ref = make_ref(),
+    ClientPid = spawn(fun() -> timer:sleep(50000) end),
+    Pid ! {self(), debug},
+    {ok, S1} = read(),
+    Pid ! {self(), Ref, {subscribe, ClientPid}},
+    {ok, M1} = read(),
+    Pid ! {self(), debug},
+    {ok, S2} = read(),
+    exit(ClientPid, testkill),
+    timer:sleep(100),
+    Pid ! {self(), debug},
+    {ok, S3} = read(),
+    [?_assertMatch({state, _, []}, S1),
+     ?_assertEqual({Ref, ok}, M1),
+     ?_assertMatch({state, _, [{_,ClientPid}]}, S2),
+     ?_assertEqual(S1, S3)].
+
+add(Pid) ->
+    Ref1 = make_ref(),
+    Ref2 = make_ref(),
+    Pid ! {self(), Ref1, {add, "test", "a test event", ?FUTURE_DATE}},
+    {ok, M1} = read(),
+    Pid ! {self(), Ref2, {add, "test", "a test event2", wrong_date}},
+    {ok, M2} = read(),
+    [?_assertEqual({Ref1, ok}, M1),
+     ?_assertEqual({Ref2, {error, bad_timeout}}, M2)].
+
+addremove(Pid) ->
+    Ref1 = make_ref(),
+    Ref2 = make_ref(),
+    Ref3 = make_ref(),
+    %% ask for useless deletion, check the state
+    Pid ! {self(), Ref1, {cancel, "nonexist"}},
+    {ok, M1} = read(),
+    Pid ! {self(), debug},
+    {ok, State1} = read(),
+    %% add an event, check the state
+    Pid ! {self(), Ref2, {add, "test", "a test event", ?FUTURE_DATE}},
+    {ok, M2} = read(),
+    Pid ! {self(), debug},
+    {ok, State2} = read(),
+    %% remove the event, check the state
+    Pid ! {self(), Ref3, {cancel, "test"}},
+    {ok, M3} = read(),
+    Pid ! {self(), debug},
+    {ok, State3} = read(),
+    [?_assertEqual({Ref1, ok}, M1),
+     ?_assertEqual({Ref2, ok}, M2),
+     ?_assertEqual({Ref3, ok}, M3),
+     ?_assertEqual(State1, State3),
+     ?_assert(State2 =/= State3),
+     ?_assertMatch({state,[{"test", {event,"test",_,_,?FUTURE_DATE}}],_}, State2)].
+
+done(Pid) ->
+    Ref = make_ref(),
+    {ok, _} = evserv:subscribe(self()),
+    Pid ! {self(), debug},
+    {ok, S1} = read(),
+    {Date,{H,Min,S}} = calendar:local_time(),
+    DateTime = {Date,{H,Min,S+1}},
+    Pid ! {self(), Ref, {add, "test", "a test event", DateTime}},
+    {ok, M1} = read(),
+    Pid ! {self(), debug},
+    {ok, S2} = read(),
+    X = read(),
+    timer:sleep(750),
+    {ok, M2} = read(),
+    Pid ! {self(), debug},
+    {ok, S3} = read(),
+    [?_assertMatch({state, [], _}, S1),
+     ?_assertEqual({Ref, ok}, M1),
+     ?_assertMatch({state, [{"test",_}], _}, S2),
+     ?_assertEqual(timeout, X),
+     ?_assertEqual({done, "test", "a test event"}, M2),
+     ?_assertEqual(S1,S3)].
+
+interface(_Pid) ->
+    Ref = evserv:subscribe(self()),
+    {Date,{H,Min,S}} = calendar:local_time(),
+    M1 = evserv:add_event("test", "desc", {Date,{H,Min,S+1}}),
+    M2 = evserv:cancel("test"),
+    M3 = evserv:add_event("test1", "desc1", calendar:local_time()),
+    M4 = evserv:add_event2("test2", "desc2", calendar:local_time()),
+    timer:sleep(100),
+    M5 = evserv:listen(2),
+    M6 = evserv:add_event("test3", "desc3", some_atom),
+    M7 = (catch evserv:add_event2("test4", "desc4", some_atom)),
+    [?_assertMatch({ok, _}, Ref),
+     ?_assert(is_reference(element(2, Ref))),
+     ?_assertEqual(ok, M1),
+     ?_assertEqual(ok, M2),
+     ?_assertEqual(ok, M3),
+     ?_assertEqual(ok, M4),
+     ?_assertEqual([{done,"test1","desc1"},{done,"test2","desc2"}], M5),
+     ?_assertEqual({error, bad_timeout}, M6),
+     ?_assertMatch({'EXIT', {bad_timeout,_}}, M7)].
+
+
+%% helpers
+terminate(Pid) -> Pid ! shutdown.
+
+read() ->
+    receive
+        M -> {ok, M}
+    after 500 ->
+        timeout
+    end.
+
diff --git a/learn-you-some-erlang/reminder/src/tests/sup_tests.erl b/learn-you-some-erlang/reminder/src/tests/sup_tests.erl
new file mode 100644
index 0000000..28d7fa9
--- /dev/null
+++ b/learn-you-some-erlang/reminder/src/tests/sup_tests.erl
@@ -0,0 +1,25 @@
+-module(sup_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+restart_test_() ->
+    {"Test that everything restarts until a kill",
+     {setup,
+      fun() -> sup:start(evserv, []) end,
+      fun(_) -> ok end,
+      fun restart/1}}.
+
+restart(_SupPid) ->
+    timer:sleep(100),
+    A = is_pid(whereis(evserv)),
+    catch exit(whereis(evserv), die),
+    timer:sleep(100),
+    B = is_pid(whereis(evserv)),
+    catch exit(whereis(evserv), die),
+    timer:sleep(100),
+    C = is_pid(whereis(evserv)),
+    catch exit(whereis(evserv), shutdown),
+    timer:sleep(500),
+    D = is_pid(whereis(evserv)),
+    ?_assertEqual([true,true,true,false],
+                  [A,B,C,D]).
+
diff --git a/learn-you-some-erlang/road.erl b/learn-you-some-erlang/road.erl
new file mode 100644
index 0000000..fa34f5a
--- /dev/null
+++ b/learn-you-some-erlang/road.erl
@@ -0,0 +1,39 @@
+-module(road).
+-compile(export_all).
+
+main([FileName]) ->
+    {ok, Bin} = file:read_file(FileName),
+    Map = parse_map(Bin),
+    io:format("~p~n",[optimal_path(Map)]),
+    erlang:halt().
+
+%% Transform a string into a readable map of triples
+parse_map(Bin) when is_binary(Bin) ->
+    parse_map(binary_to_list(Bin));
+parse_map(Str) when is_list(Str) ->
+    Values = [list_to_integer(X) || X <- string:tokens(Str,"\r\n\t ")],
+    group_vals(Values, []).
+
+group_vals([], Acc) ->
+    lists:reverse(Acc);
+group_vals([A,B,X|Rest], Acc) ->
+    group_vals(Rest, [{A,B,X} | Acc]).
+
+%% Picks the best of all paths, woo!
+optimal_path(Map) ->
+    {A,B} = lists:foldl(fun shortest_step/2, {{0,[]}, {0,[]}}, Map),
+    {_Dist,Path} = if hd(element(2,A)) =/= {x,0} -> A;
+                      hd(element(2,B)) =/= {x,0} -> B
+                   end,
+    lists:reverse(Path).
+
+%% actual problem solving
+%% change triples of the form {A,B,X}
+%% where A,B,X are distances and a,b,x are possible paths
+%% to the form {DistanceSum, PathList}.
+shortest_step({A,B,X}, {{DistA,PathA}, {DistB,PathB}}) ->
+    OptA1 = {DistA + A, [{a,A}|PathA]},
+    OptA2 = {DistB + B + X, [{x,X}, {b,B}|PathB]},
+    OptB1 = {DistB + B, [{b,B}|PathB]},
+    OptB2 = {DistA + A + X, [{x,X}, {a,A}|PathA]},
+    {erlang:min(OptA1, OptA2), erlang:min(OptB1, OptB2)}.
diff --git a/learn-you-some-erlang/road.txt b/learn-you-some-erlang/road.txt
new file mode 100644
index 0000000..fa6997e
--- /dev/null
+++ b/learn-you-some-erlang/road.txt
@@ -0,0 +1,12 @@
+50
+10
+30
+5
+90
+20
+40
+2
+25
+10
+8
+0
diff --git a/learn-you-some-erlang/tester.erl b/learn-you-some-erlang/tester.erl
new file mode 100644
index 0000000..f1d1b1c
--- /dev/null
+++ b/learn-you-some-erlang/tester.erl
@@ -0,0 +1,55 @@
+-module(tester).
+-export([dir/0, dir/2]).
+-define(EXT, ".erl"). % file extension to look for
+-define(MODS, "./").
+-define(TESTS, "./tests/").
+
+%% scans both a module directory and a test directory, compiles the
+%% modules inside and then call for tests to be ran.
+%%
+%% usage:
+%%     tester:dir("./","./tests/").
+dir() -> dir(?MODS, ?TESTS).
+dir(ModulePath, TestPath) ->
+    ModuleList = module_list(ModulePath),
+    TestList = module_list(TestPath),
+    [compile(ModulePath++X) || X <- ModuleList],
+    [compile(TestPath++X) || X <- TestList],
+    test_all(TestList),
+    warnings(),
+    cleanup(ModuleList),
+    cleanup(TestList),
+    ok.
+
+%% assumes pre-compiled modules
+test_all(FileList) ->
+    Split = [lists:nth(1, string:tokens(File, ".")) || File <- FileList],
+    [eunit:test(list_to_existing_atom(F), [verbose]) || F <- Split].
+   % [(list_to_existing_atom(F)):test() || F <- Split].
+
+cleanup(Files) ->
+    [file:delete(lists:nth(1, string:tokens(F, "."))++".beam") || F <- Files].
+
+%% get module .erl file names from a directory
+module_list(Path) ->
+    SameExt = fun(File) -> get_ext(File) =:= ?EXT end,
+    {ok, Files} = file:list_dir(Path),
+    lists:filter(SameExt, Files).
+
+%% find the extension of a file (length is taken from the ?EXT macro).
+get_ext(Str) ->
+    lists:reverse(string:sub_string(lists:reverse(Str), 1, length(?EXT))).
+
+compile(FileName) ->
+    compile:file(FileName, [report, verbose, export_all]).
+
+warnings() ->
+    Warns = [{Mod, get_warnings(Mod)} || {Mod,_Path} <- code:all_loaded(),
+                                         has_warnings(Mod)],
+    io:format("These need to be tested better: ~n\t~p~n", [Warns]).
+
+has_warnings(Mod) ->
+    is_list(get_warnings(Mod)).
+
+get_warnings(Mod) ->
+    proplists:get_value(test_warnings, Mod:module_info(attributes)).
diff --git a/learn-you-some-erlang/tests/calc_tests.erl b/learn-you-some-erlang/tests/calc_tests.erl
new file mode 100644
index 0000000..4f6f530
--- /dev/null
+++ b/learn-you-some-erlang/tests/calc_tests.erl
@@ -0,0 +1,6 @@
+-module(calc_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+%% runs the unit test function defined in calc.erl
+all_test() ->
+    ?assert(ok =:= calc:rpn_test()).
diff --git a/learn-you-some-erlang/tests/cases_tests.erl b/learn-you-some-erlang/tests/cases_tests.erl
new file mode 100644
index 0000000..5b7bd0b
--- /dev/null
+++ b/learn-you-some-erlang/tests/cases_tests.erl
@@ -0,0 +1,24 @@
+-module(cases_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+insert_test_() ->
+    [?_assertEqual([1], cases:insert(1,[])),
+     ?_assertEqual([1], cases:insert(1,[1])),
+     ?_assertEqual([1,2], cases:insert(1,[2]))].
+
+beach_test_() ->
+    [?_assertEqual('favorable', cases:beach({celsius, 20})),
+     ?_assertEqual('favorable', cases:beach({celsius, 45})),
+     ?_assertEqual('avoid beach', cases:beach({celsius, 46})),
+     ?_assertEqual('avoid beach', cases:beach({celsius, 19})),
+     ?_assertEqual('scientifically favorable', cases:beach({kelvin, 293})),
+     ?_assertEqual('scientifically favorable', cases:beach({kelvin, 318})),
+     ?_assertEqual('avoid beach', cases:beach({kelvin, 292})),
+     ?_assertEqual('avoid beach', cases:beach({celsius, 319})),
+     ?_assertEqual('favorable in the US',
+                   cases:beach({fahrenheit, 68})),
+     ?_assertEqual('favorable in the US',
+                   cases:beach({fahrenheit, 113})),
+     ?_assertEqual('avoid beach', cases:beach({fahrenheit, 67})),
+     ?_assertEqual('avoid beach', cases:beach({fahrenheit, 114})),
+     ?_assertEqual('avoid beach', cases:beach(cat))].
diff --git a/learn-you-some-erlang/tests/cat_fsm_tests.erl b/learn-you-some-erlang/tests/cat_fsm_tests.erl
new file mode 100644
index 0000000..aa4b940
--- /dev/null
+++ b/learn-you-some-erlang/tests/cat_fsm_tests.erl
@@ -0,0 +1,21 @@
+-module(cat_fsm_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+cat_fsm_test_() ->
+    {setup, fun setup/0, fun teardown/1, fun state_test_/1}.
+
+setup() ->
+    cat_fsm:start().
+
+teardown(Pid) ->
+    exit(Pid, end_test).
+    
+state_test_(Pid) ->
+    [?_assertEqual(dont_give_crap, get_state(Pid)),
+     ?_assertEqual({ok, meh}, cat_fsm:event(Pid, event)),
+     ?_assertEqual(dont_give_crap, get_state(Pid))].
+
+get_state(Pid) ->
+    List = erlang:process_info(Pid),
+    {_, {_Mod, Fn, _Arity}} = lists:keyfind(current_function, 1, List),
+    Fn.
diff --git a/learn-you-some-erlang/tests/dog_fsm_tests.erl b/learn-you-some-erlang/tests/dog_fsm_tests.erl
new file mode 100644
index 0000000..7217244
--- /dev/null
+++ b/learn-you-some-erlang/tests/dog_fsm_tests.erl
@@ -0,0 +1,81 @@
+-module(dog_fsm_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+bark_test_() ->
+    {foreach,
+     fun setup_bark/0,
+     fun teardown/1,
+     [fun bark_pet_test_/1, fun bark_other_test_/1]}.
+
+wag_tail_test_() ->
+    {foreach,
+     fun setup_wag_tail/0,
+     fun teardown/1,
+     [fun wag_pet_test_/1, fun wag_other_test_/1]}.
+
+sit_test_() ->
+    {foreach,
+     fun setup_sit/0,
+     fun teardown/1,
+     [fun sit_squirrel_test_/1, fun sit_other_test_/1]}.
+
+setup_bark() ->
+    Pid = dog_fsm:start(),
+    timer:sleep(100),
+    Pid.
+
+setup_wag_tail() ->
+    Pid = dog_fsm:start(),
+    dog_fsm:pet(Pid),
+    timer:sleep(100),
+    Pid.
+
+setup_sit() ->
+    Pid = dog_fsm:start(),
+    dog_fsm:pet(Pid),
+    dog_fsm:pet(Pid),
+    timer:sleep(100),
+    Pid.
+
+teardown(Pid) ->
+    exit(Pid, end_test).
+    
+init_test() ->
+    Pid = dog_fsm:start(),
+    timer:sleep(100),
+    ?assertEqual(bark, get_state(Pid)).
+    
+bark_pet_test_(Pid) ->
+    [?_assertEqual(bark, get_state(Pid)),
+     ?_assertEqual(pet, dog_fsm:pet(Pid)),
+     begin timer:sleep(100), ?_assertEqual(wag_tail, get_state(Pid)) end].
+
+bark_other_test_(Pid) ->
+    [?_assertEqual(bark, get_state(Pid)),
+     ?_assertEqual(squirrel, dog_fsm:squirrel(Pid)),
+     begin timer:sleep(100), ?_assertEqual(bark, get_state(Pid)) end].
+
+wag_pet_test_(Pid) ->
+    [?_assertEqual(wag_tail, get_state(Pid)),
+     ?_assertEqual(pet, dog_fsm:pet(Pid)),
+     begin timer:sleep(100), ?_assertEqual(sit, get_state(Pid)) end].
+
+wag_other_test_(Pid) ->
+    [?_assertEqual(wag_tail, get_state(Pid)),
+     ?_assertEqual(squirrel, dog_fsm:squirrel(Pid)),
+     begin timer:sleep(100), ?_assertEqual(wag_tail, get_state(Pid)) end].
+
+sit_squirrel_test_(Pid) ->
+    [?_assertEqual(sit, get_state(Pid)),
+     ?_assertEqual(squirrel, dog_fsm:squirrel(Pid)),
+     begin timer:sleep(100), ?_assertEqual(bark, get_state(Pid)) end].
+    
+sit_other_test_(Pid) ->
+    [?_assertEqual(sit, get_state(Pid)),
+     ?_assertEqual(pet, dog_fsm:pet(Pid)),
+     begin timer:sleep(100), ?_assertEqual(sit, get_state(Pid)) end].
+
+get_state(Pid) ->
+    List = erlang:process_info(Pid),
+    {_, {_Mod, Fn, _Arity}} = lists:keyfind(current_function, 1, List),
+    Fn.
diff --git a/learn-you-some-erlang/tests/dolphins_tests.erl b/learn-you-some-erlang/tests/dolphins_tests.erl
new file mode 100644
index 0000000..670f6a2
--- /dev/null
+++ b/learn-you-some-erlang/tests/dolphins_tests.erl
@@ -0,0 +1,87 @@
+-module(dolphins_tests).
+-include_lib("eunit/include/eunit.hrl").
+%% sorry, this test library is a bit dirty, but it should do
+%% the job.
+
+%% cannot test dolphin1/0 for lack of any results outside of I/O.
+-test_warnings([dolphin1/0]).
+
+dolphin2_test_() ->
+    [?_assertEqual("How about no?", d2_do_a_flip()),
+     ?_assertEqual("So long and thanks for all the fish!",
+                   d2_fish())].
+
+d2_do_a_flip() ->
+    Pid = spawn(dolphins, dolphin2, []),
+    Pid ! Pid ! {self(), do_a_flip},
+    %% this function receives a message and that's it
+    F = fun() ->
+        receive
+            M -> M
+        after 500 ->
+            error
+        end
+    end,
+    %% receive the first message
+    Msg1 = F(),
+    %% only one message should be received. If the second one
+    %% is anything except 'error' (no message), return an error.
+    %% otherwise send the message for validation.
+    case F() of         
+        error -> Msg1;  
+        _ -> error
+    end.
+    
+d2_fish() ->
+    Pid = spawn(dolphins, dolphin2, []),
+    Pid ! Pid ! {self(), fish},
+    %% this function receives a message and that's it
+    F = fun() ->
+        receive
+            M -> M
+        after 500 ->
+            error
+        end
+    end,
+    %% receive the first message
+    Msg1 = F(),
+    %% only one message should be received. If the second one
+    %% is anything except 'error' (no message), return an error.
+    %% otherwise send the message for validation.
+    case F() of         
+        error -> Msg1;  
+        _ -> error
+    end.
+
+dolphin3_test_() ->
+    [?_assertEqual(["How about no?",
+                    "How about no?",
+                    "So long and thanks for all the fish!"],
+                    d3())].
+
+d3() ->
+    Pid = spawn(dolphins, dolphin3, []),
+    Pid ! Pid ! {self(), do_a_flip}, % both should be received
+    Pid ! invalid, % should be ignored, but keep the process going
+    Pid ! {self(), fish}, % should terminate the process
+    Pid ! {self(), do_a_flip}, % should return nothing
+    %% this function receives a message and that's it
+    F = fun() ->
+        receive
+            M -> M
+        after 500 ->
+            error
+        end
+    end,
+    %% receive the expected messages
+    Msg1 = F(),
+    Msg2 = F(),
+    Msg3 = F(),
+    Msgs = [Msg1, Msg2, Msg3],
+    %% Additional messages should now fail. If a message is
+    %% received, add it to the list and let the test fail,
+    %% otherwise send the normal message list.
+    case F() of         
+        error -> Msgs;  
+        M -> Msgs ++ [M]
+    end.
diff --git a/learn-you-some-erlang/tests/exceptions_tests.erl b/learn-you-some-erlang/tests/exceptions_tests.erl
new file mode 100644
index 0000000..6adfd24
--- /dev/null
+++ b/learn-you-some-erlang/tests/exceptions_tests.erl
@@ -0,0 +1,61 @@
+-module(exceptions_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+throws_test_() ->
+    [?_assertEqual(ok, exceptions:throws(fun() -> a end)),
+     ?_assertException(error, {badfun, _} , exceptions:throws(a)),
+     ?_assertEqual({throw, caught, a},
+                   exceptions:throws(fun() -> throw(a) end))].
+
+errors_test_() ->
+    [?_assertEqual(ok, exceptions:errors(fun() -> a end)),
+     ?_assertException(throw,
+                       a,
+                       exceptions:errors(fun() -> throw(a) end)),
+     ?_assertEqual({error, caught, a},
+                   exceptions:errors(fun() -> erlang:error(a) end))].
+exits_test_() ->
+    [?_assertEqual(ok, exceptions:exits(fun() -> a end)),
+     ?_assertException(error, {badfun, _}, exceptions:exits(a)),
+     ?_assertEqual({exit, caught, a},
+                   exceptions:exits(fun() -> exit(a) end))].
+
+talk_test() ->
+    ?assertEqual("blah blah", exceptions:talk()).
+
+sword_test_() ->
+    [?_assertException(throw, slice, exceptions:sword(1)),
+     ?_assertException(error, cut_arm, exceptions:sword(2)),
+     ?_assertException(exit, cut_leg, exceptions:sword(3)),
+     ?_assertException(throw, punch, exceptions:sword(4)),
+     ?_assertException(exit, cross_bridge, exceptions:sword(5))].
+
+black_knight_test_() ->
+    [?_assertEqual("None shall pass.",
+                   exceptions:black_knight(fun exceptions:talk/0)),
+     ?_assertEqual("It is but a scratch.",
+                   exceptions:black_knight(fun() -> exceptions:sword(1) end)),
+     ?_assertEqual("I've had worse.",
+                   exceptions:black_knight(fun() -> exceptions:sword(2) end)),
+     ?_assertEqual("Come on you pansy!",
+                   exceptions:black_knight(fun() -> exceptions:sword(3) end)),
+     ?_assertEqual("Just a flesh wound.",
+                   exceptions:black_knight(fun() -> exceptions:sword(4) end)),
+     ?_assertEqual("Just a flesh wound.",
+                   exceptions:black_knight(fun() -> exceptions:sword(5) end))].
+
+whoa_test() ->
+    ?assertEqual({caught, throw, up}, exceptions:whoa()).
+
+im_impressed_test() ->
+    ?assertEqual({caught, throw, up}, exceptions:im_impressed()).
+
+catcher_test_() ->
+    [?_assertEqual("uh oh", exceptions:catcher(1,0)),
+     ?_assertEqual(1.0, exceptions:catcher(3,3)),
+     ?_assertEqual(2.0, exceptions:catcher(6,3))].
+
+one_or_two_test_() ->
+    [?_assertEqual(return, exceptions:one_or_two(1)),
+     ?_assertEqual(return, catch exceptions:one_or_two(2)),
+     ?_assertException(throw, return, exceptions:one_or_two(2))].
diff --git a/learn-you-some-erlang/tests/fifo_tests.erl b/learn-you-some-erlang/tests/fifo_tests.erl
new file mode 100644
index 0000000..1252a1b
--- /dev/null
+++ b/learn-you-some-erlang/tests/fifo_tests.erl
@@ -0,0 +1,22 @@
+-module(fifo_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+new_test() -> ?assertEqual({fifo,[],[]}, fifo:new()).
+
+push_test_() ->
+    [?_assertEqual({fifo,[1,3],[2,4]}, fifo:push({fifo,[3],[2,4]},1)),
+     ?_assertEqual({fifo,[2],[]}, fifo:push({fifo,[],[]},2))].
+
+pop_test_() ->
+    [?_assertEqual({3,{fifo,[],[2]}}, fifo:pop({fifo,[],[3,2]})),
+     ?_assertEqual({3,{fifo,[],[2]}}, fifo:pop({fifo,[2,3],[]})),
+     ?_assertEqual({3,{fifo,[2,1],[]}},fifo:pop({fifo,[2,1],[3]})),
+     ?_assertEqual({1,{fifo,[],[2,3]}},
+                   fifo:pop(fifo:push(fifo:push(fifo:push(fifo:new(),1),2),3))),
+     ?_assertError('empty fifo', fifo:pop({fifo,[],[]}))].
+
+empty_test_() ->
+    [?_assertEqual(true, fifo:empty(fifo:new())),
+     ?_assertEqual(false, fifo:empty({fifo,[1],[]})),
+     ?_assertEqual(false, fifo:empty({fifo,[],[1]})),
+     ?_assertEqual(false, fifo:empty({fifo,[1],[2]}))].
diff --git a/learn-you-some-erlang/tests/functions_tests.erl b/learn-you-some-erlang/tests/functions_tests.erl
new file mode 100644
index 0000000..7973b9e
--- /dev/null
+++ b/learn-you-some-erlang/tests/functions_tests.erl
@@ -0,0 +1,27 @@
+-module(functions_tests).
+-include_lib("eunit/include/eunit.hrl").
+-test_warnings([valid_time_test/0]).
+
+head_test() -> ?assertEqual(1, functions:head([1,2,3,4])).
+
+second_test() -> ?assertEqual(2, functions:second([1,2,3,4])).
+
+same_test_() ->
+    [?_assertEqual(true, functions:same(a,a)),
+     ?_assertEqual(true, functions:same(12,12)),
+     ?_assertEqual(false, functions:same(a,b)),
+     ?_assertEqual(false, functions:same(12.0, 12))].
+
+%% no clean way to test valid_time's io stuff, so this one is p. much the
+%% same thing as the main objective was to test pattern matching.
+%% io:format should be used as least as possible to do testing :(
+valid_time({_Date = {_Y,_M,_D}, _Time = {_H,_Min,_S}}) ->
+    matches;
+valid_time(_) ->
+    nomatch.
+
+valid_time_test_() ->
+    [?_assertEqual(matches, valid_time({{2011,09,06},{09,04,43}})),
+     ?_assertEqual(nomatch, valid_time({{2011,09,06},{09,04}}))].
+
+
diff --git a/learn-you-some-erlang/tests/guards_tests.erl b/learn-you-some-erlang/tests/guards_tests.erl
new file mode 100644
index 0000000..d908bcf
--- /dev/null
+++ b/learn-you-some-erlang/tests/guards_tests.erl
@@ -0,0 +1,22 @@
+-module(guards_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+old_enough_test_() ->
+    [?_assertEqual(true, guards:old_enough(16)),
+     ?_assertEqual(false, guards:old_enough(15)),
+     ?_assertEqual(false, guards:old_enough(-16))].
+
+right_age_test_() ->
+    [?_assertEqual(true, guards:right_age(16)),
+     ?_assertEqual(true, guards:right_age(104)),
+     ?_assertEqual(true, guards:right_age(50)),
+     ?_assertEqual(false, guards:right_age(15)),
+     ?_assertEqual(false, guards:right_age(105))].
+
+wrong_age_test_() ->
+    [?_assertEqual(false, guards:wrong_age(16)),
+     ?_assertEqual(false, guards:wrong_age(104)),
+     ?_assertEqual(false, guards:wrong_age(50)),
+     ?_assertEqual(true, guards:wrong_age(15)),
+     ?_assertEqual(true, guards:wrong_age(105))].
+
diff --git a/learn-you-some-erlang/tests/hhfuns_tests.erl b/learn-you-some-erlang/tests/hhfuns_tests.erl
new file mode 100644
index 0000000..c5c27cf
--- /dev/null
+++ b/learn-you-some-erlang/tests/hhfuns_tests.erl
@@ -0,0 +1,95 @@
+-module(hhfuns_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+one_test() ->
+    ?assertEqual(1, hhfuns:one()).
+
+two_test() ->
+    ?assertEqual(2, hhfuns:two()).
+
+add_test_() ->
+    [?_assertEqual(3, hhfuns:add(fun hhfuns:one/0, fun hhfuns:two/0)),
+     ?_assertError({badfun, _}, hhfuns:add(1,2)),
+     ?_assertEqual(2, hhfuns:add(fun hhfuns:one/0, fun hhfuns:one/0))].
+
+increment_test() ->
+    ?assertEqual([1,2,3], hhfuns:increment([0,1,2])).
+
+decrement_test() ->
+    ?assertEqual([1,2,3], hhfuns:decrement([2,3,4])).
+
+map_test_() ->
+    [?_assertEqual([1,2,3], hhfuns:map(fun hhfuns:incr/1, [0,1,2])),
+     ?_assertEqual([1,2,3], hhfuns:map(fun hhfuns:decr/1, [2,3,4]))].
+
+bases_test_() ->
+    [?_assertEqual(12, hhfuns:base1(3)),
+     ?_assertError({badmatch, _}, hhfuns:base2()),
+     ?_assertEqual(2, hhfuns:base3())].
+
+closure_test() ->
+    ?assertEqual("a/0's password is pony", hhfuns:b(hhfuns:a())).
+
+even_test_() ->
+    [?_assertEqual([], hhfuns:even([])),
+     ?_assertEqual([], hhfuns:even([3,5,7])),
+     ?_assertEqual([2,4], hhfuns:even([1,2,3,4]))].
+
+old_test_() ->
+    L = [{male,45},{female,67},{male,66},{female,12},{unkown,174},{male,74}], 
+    [?_assertEqual([{male,66},{male,74}], hhfuns:old_men(L)),
+     ?_assertEqual([], hhfuns:old_men([{male,45}, {female, -54}])),
+     ?_assertEqual([], hhfuns:old_men([]))].
+       
+filter_test_() ->
+    L = [{male,45},{female,67},{male,66},{female,12},{unkown,174},{male,74}], 
+    IsEven = fun(X) -> X rem 2 == 0 end,
+    IsOldMale = fun({Gender, Age}) -> Gender == male andalso Age > 60 end,
+    [?_assertEqual([], hhfuns:filter(IsEven, [])),
+     ?_assertEqual([], hhfuns:filter(IsEven, [3,5,7])),
+     ?_assertEqual([2,4], hhfuns:filter(IsEven, [1,2,3,4])),
+     ?_assertEqual([{male,66},{male,74}], hhfuns:filter(IsOldMale, L)),
+     ?_assertEqual([], hhfuns:filter(IsOldMale, [{male,45}, {female, -54}])),
+     ?_assertEqual([], hhfuns:filter(IsOldMale, []))].
+       
+max_test_() ->
+    [?_assertEqual(3, hhfuns:max([1,2,3])),
+     ?_assertEqual(-1, hhfuns:max([-10,-1,-5.5])),
+     ?_assertError(function_clause, hhfuns:max([]))].
+
+min_test_() ->
+    [?_assertEqual(0, hhfuns:min([1,2,0,3])),
+     ?_assertEqual(-10, hhfuns:min([-10,-1,-5.5])),
+     ?_assertError(function_clause, hhfuns:min([]))].
+
+sum_test_() ->
+    [?_assertEqual(0, hhfuns:sum([])),
+     ?_assertEqual(6, hhfuns:sum([1,2,3]))].
+
+fold_test_() ->
+    [H|T] = [1,7,3,5,9,0,2,3],
+    [?_assertEqual(9,
+                   hhfuns:fold(fun(A,B) when A > B -> A; (_,B) -> B end, H, T)),
+     ?_assertEqual(0,
+                   hhfuns:fold(fun(A,B) when A < B -> A; (_,B) -> B end, H, T)),
+     ?_assertEqual(21, hhfuns:fold(fun(A,B) -> A + B end, 0, lists:seq(1,6)))].
+
+reverse_test_() ->
+    [?_assertEqual([3,2,1], hhfuns:reverse([1,2,3])),
+     ?_assertEqual([], hhfuns:reverse([]))].
+
+map2_test_() ->
+    [?_assertEqual([1,2,3], hhfuns:map2(fun hhfuns:incr/1, [0,1,2])),
+     ?_assertEqual([1,2,3], hhfuns:map2(fun hhfuns:decr/1, [2,3,4]))].
+
+
+filter2_test_() ->
+    L = [{male,45},{female,67},{male,66},{female,12},{unkown,174},{male,74}],
+    IsEven = fun(X) -> X rem 2 == 0 end,
+    IsOldMale = fun({Gender, Age}) -> Gender == male andalso Age > 60 end,
+    [?_assertEqual([], hhfuns:filter2(IsEven, [])),
+     ?_assertEqual([], hhfuns:filter2(IsEven, [3,5,7])),
+     ?_assertEqual([2,4], hhfuns:filter2(IsEven, [1,2,3,4])),
+     ?_assertEqual([{male,66},{male,74}], hhfuns:filter2(IsOldMale, L)),
+     ?_assertEqual([], hhfuns:filter2(IsOldMale, [{male,45}, {female, -54}])),
+     ?_assertEqual([], hhfuns:filter2(IsOldMale, []))].
diff --git a/learn-you-some-erlang/tests/kitchen_tests.erl b/learn-you-some-erlang/tests/kitchen_tests.erl
new file mode 100644
index 0000000..821f60c
--- /dev/null
+++ b/learn-you-some-erlang/tests/kitchen_tests.erl
@@ -0,0 +1,118 @@
+-module(kitchen_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+fridge1_test_() ->
+    {"Tests fridge1 although the function is never run in the text",
+     {foreach,
+      fun() -> spawn(kitchen, fridge1, []) end,
+      fun(Pid) -> exit(Pid, kill) end,
+      [fun fridge1_store/1,
+       fun fridge1_take/1]
+     }
+    }.
+
+fridge1_store(Pid) ->
+    Pid ! {self(), {store, item}},
+    Reply = receive_or_timeout(),
+    [?_assertEqual({Pid, ok}, Reply)].
+
+fridge1_take(Pid) ->
+    Pid ! {self(), {take, item}},
+    Reply = receive_or_timeout(),
+    [?_assertEqual({Pid, not_found}, Reply)].
+
+
+fridge2_test_() ->
+    {"Tests fridge2",
+     {foreach,
+      fun() -> spawn(kitchen, fridge2, [[]]) end,
+      fun(Pid) -> exit(Pid, kill) end,
+      [fun fridge2_store/1,
+       fun fridge2_take_nostore/1,
+       fun fridge2_take_stored/1]
+     }
+    }.
+
+fridge2_store(Pid) ->
+    Pid ! {self(), {store, item}},
+    Pid ! {self(), {store, item2}},
+    Reply1 = receive_or_timeout(),
+    Reply2 = receive_or_timeout(),
+    [?_assertEqual({Pid, ok}, Reply1),
+     ?_assertEqual({Pid, ok}, Reply2)].
+
+fridge2_take_nostore(Pid) ->
+    Pid ! {self(), {take, item}},
+    Reply = receive_or_timeout(),
+    [?_assertEqual({Pid, not_found}, Reply)].
+
+fridge2_take_stored(Pid) ->
+    Pid ! {self(), {store, item}},
+    _ = receive_or_timeout(), % flush the 'ok' msg
+    Pid ! {self(), {take, item}},
+    Pid ! {self(), {take, item}}, % check if the food is removed
+    R1 = receive_or_timeout(),
+    R2 = receive_or_timeout(),
+    [?_assertEqual({Pid, {ok, item}}, R1),
+     ?_assertEqual({Pid, not_found}, R2)].
+
+
+abstractions_test_() ->
+    {"Tests the abstraction function we added to the script",
+     [{"Basic take/2 and store/2 abstractions. Can't test the hanging.",
+       {foreach,
+        fun() -> spawn(kitchen, fridge2, [[]]) end,
+        fun(Pid) -> exit(Pid, kill) end,
+        [fun store/1,
+         fun take/1]
+       }},
+      {"Start/1 abstraction tests. Reuses the take/2 and store/2 tests.",
+       {foreach,
+        fun() -> kitchen:start([]) end,
+        fun(Pid) -> exit(Pid, kill) end,
+        [fun store/1,
+         fun take/1]
+       }},
+      {"take2/2 and store2/2 tests.",
+       {timeout, 10,
+        {foreach,
+         fun() -> kitchen:start([]) end,
+         fun(Pid) -> exit(Pid, kill) end,
+         [fun store2/1,
+          fun take2/1]
+        }
+      }}
+     ]
+    }.
+
+store(Pid) ->
+    [?_assertEqual(ok, kitchen:store(Pid, item))].
+
+take(Pid) ->
+    kitchen:store(Pid, item),
+    R1 = kitchen:take(Pid, item),
+    R2 = kitchen:take(Pid, item),
+    [?_assertEqual({ok, item}, R1),
+     ?_assertEqual(not_found, R2)].
+
+store2(Pid) ->
+    R1 = kitchen:store2(c:pid(0,7,0), item),
+    R2 = kitchen:store2(Pid, item),
+    [?_assertEqual(timeout, R1),
+     ?_assertEqual(ok, R2)].
+
+take2(Pid) ->
+    kitchen:store2(Pid, item),
+    R1 = kitchen:take2(c:pid(0,7,0), item),
+    R2 = kitchen:take2(Pid, item),
+    R3 = kitchen:take2(Pid, item),
+    [?_assertEqual(timeout, R1),
+     ?_assertEqual({ok, item}, R2),
+     ?_assertEqual(not_found, R3)].
+
+receive_or_timeout() ->
+    receive
+        M -> M
+    after 1000 ->
+        timeout
+    end.
diff --git a/learn-you-some-erlang/tests/kitty_gen_server_tests.erl b/learn-you-some-erlang/tests/kitty_gen_server_tests.erl
new file mode 100644
index 0000000..e167158
--- /dev/null
+++ b/learn-you-some-erlang/tests/kitty_gen_server_tests.erl
@@ -0,0 +1,19 @@
+-module(kitty_gen_server_tests).
+-record(cat, {name, color=green, description}). % stolen from kitty_gen_server.erl
+-include_lib("eunit/include/eunit.hrl").
+-define(CAT1, #cat{name=a, color=b, description=c}).
+-define(CAT2, #cat{name=d, color=e, description=f}).
+
+order_test() ->
+    {ok, Pid} = kitty_gen_server:start_link(),
+    ?assertEqual(?CAT1, kitty_gen_server:order_cat(Pid, a, b, c)),
+    ?assertEqual(?CAT2, kitty_gen_server:order_cat(Pid, d, e, f)),
+    ?assertEqual(ok, kitty_gen_server:close_shop(Pid)).
+
+return_test() ->
+    {ok, Pid} = kitty_gen_server:start_link(),
+    ?assertEqual(ok, kitty_gen_server:return_cat(Pid, ?CAT1)),
+    ?assertEqual(?CAT1, kitty_gen_server:order_cat(Pid, d, e, f)),
+    ?assertEqual(?CAT2, kitty_gen_server:order_cat(Pid, d, e, f)),
+    ?assertEqual(ok, kitty_gen_server:close_shop(Pid)).
+
diff --git a/learn-you-some-erlang/tests/kitty_server2_tests.erl b/learn-you-some-erlang/tests/kitty_server2_tests.erl
new file mode 100644
index 0000000..a41594a
--- /dev/null
+++ b/learn-you-some-erlang/tests/kitty_server2_tests.erl
@@ -0,0 +1,23 @@
+-module(kitty_server2_tests).
+-record(cat, {name, color=green, description}). % stolen from kitty_server2.erl
+-include_lib("eunit/include/eunit.hrl").
+-define(CAT1, #cat{name=a, color=b, description=c}).
+-define(CAT2, #cat{name=d, color=e, description=f}).
+
+order_test() ->
+    Pid = kitty_server2:start_link(),
+    ?assertEqual(?CAT1, kitty_server2:order_cat(Pid, a, b, c)),
+    ?assertEqual(?CAT2, kitty_server2:order_cat(Pid, d, e, f)),
+    ?assertEqual(ok, kitty_server2:close_shop(Pid)).
+
+return_test() ->
+    Pid = kitty_server2:start_link(),
+    ?assertEqual(ok, kitty_server2:return_cat(Pid, ?CAT1)),
+    ?assertEqual(?CAT1, kitty_server2:order_cat(Pid, d, e, f)),
+    ?assertEqual(?CAT2, kitty_server2:order_cat(Pid, d, e, f)),
+    ?assertEqual(ok, kitty_server2:close_shop(Pid)).
+
+close_noproc_test() ->
+    DeadPid = spawn_link(fun() -> ok end),
+    timer:sleep(100),
+    ?assertError(noproc, kitty_server2:close_shop(DeadPid)).
diff --git a/learn-you-some-erlang/tests/kitty_server_tests.erl b/learn-you-some-erlang/tests/kitty_server_tests.erl
new file mode 100644
index 0000000..47b2561
--- /dev/null
+++ b/learn-you-some-erlang/tests/kitty_server_tests.erl
@@ -0,0 +1,23 @@
+-module(kitty_server_tests).
+-record(cat, {name, color=green, description}). % stolen from kitty_server.erl
+-include_lib("eunit/include/eunit.hrl").
+-define(CAT1, #cat{name=a, color=b, description=c}).
+-define(CAT2, #cat{name=d, color=e, description=f}).
+
+order_test() ->
+    Pid = kitty_server:start_link(),
+    ?assertEqual(?CAT1, kitty_server:order_cat(Pid, a, b, c)),
+    ?assertEqual(?CAT2, kitty_server:order_cat(Pid, d, e, f)),
+    ?assertEqual(ok, kitty_server:close_shop(Pid)).
+
+return_test() ->
+    Pid = kitty_server:start_link(),
+    ?assertEqual(ok, kitty_server:return_cat(Pid, ?CAT1)),
+    ?assertEqual(?CAT1, kitty_server:order_cat(Pid, d, e, f)),
+    ?assertEqual(?CAT2, kitty_server:order_cat(Pid, d, e, f)),
+    ?assertEqual(ok, kitty_server:close_shop(Pid)).
+
+close_noproc_test() ->
+    DeadPid = spawn_link(fun() -> ok end),
+    timer:sleep(100),
+    ?assertError(noproc, kitty_server:close_shop(DeadPid)).
diff --git a/learn-you-some-erlang/tests/linkmon_tests.erl b/learn-you-some-erlang/tests/linkmon_tests.erl
new file mode 100644
index 0000000..a04ee27
--- /dev/null
+++ b/learn-you-some-erlang/tests/linkmon_tests.erl
@@ -0,0 +1,43 @@
+-module(linkmon_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+myproc_test_() ->
+    {timeout,
+     7,
+     ?_assertEqual({'EXIT', reason},
+                   catch linkmon:myproc())}.
+
+chain_test_() ->
+    {timeout,
+     3,
+     ?_assertEqual(ok, chain_proc())}.
+
+chain_proc() ->
+    process_flag(trap_exit, true),
+    link(spawn(linkmon, chain, [3])),
+    receive
+        {'EXIT', _, "chain dies here"} -> ok
+    end.
+
+critic1_test_() ->
+    Critic = linkmon:start_critic(),
+    A = linkmon:judge(Critic, "Genesis", "The Lambda Lies Down on Broadway"),
+    exit(Critic, solar_storm),
+    B = linkmon:judge(Critic, "Genesis", "A trick of the Tail Recursion"),
+    [?_assertEqual("They are terrible!", A),
+     ?_assertEqual(timeout, B)].
+
+critic2_test_() ->
+    catch unregister(critic),
+    linkmon:start_critic2(),
+    timer:sleep(200),
+    A = linkmon:judge2("The Doors", "Light my Firewall"),
+    exit(whereis(critic), kill),
+    timer:sleep(200),
+    B = linkmon:judge2("Rage Against the Turing Machine", "Unit Testify"),
+    exit(whereis(critic), shutdown),
+    timer:sleep(200),
+    C = (catch linkmon:judge2("a", "b")),
+    [?_assertEqual("They are terrible!", A),
+     ?_assertEqual("They are great!", B),
+     ?_assertMatch({'EXIT', {badarg, _}}, C)].
diff --git a/learn-you-some-erlang/tests/multiproc_tests.erl b/learn-you-some-erlang/tests/multiproc_tests.erl
new file mode 100644
index 0000000..1020324
--- /dev/null
+++ b/learn-you-some-erlang/tests/multiproc_tests.erl
@@ -0,0 +1,28 @@
+-module(multiproc_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+%% sleep's implementation is copy/pasted from the timer module.
+%% not much to test to be safe.
+sleep_test_() ->
+    [?_assertEqual(ok, multiproc:sleep(10))].
+
+flush_test_() ->
+    {spawn,
+        [fun() ->
+            self() ! a,
+            self() ! b,
+            ok = multiproc:flush(),
+            self() ! c,
+            [?assertEqual(receive M -> M end, c)]
+         end]}.
+
+priority_test_() ->
+    {spawn,
+        [fun() ->
+            self() ! {15, high},
+            self() ! {7, low},
+            self() ! {1, low},
+            self() ! {17, high},
+            [?assertEqual([high, high, low, low],
+                          multiproc:important())]
+        end]}.
diff --git a/learn-you-some-erlang/tests/musicians_tests.erl b/learn-you-some-erlang/tests/musicians_tests.erl
new file mode 100644
index 0000000..b1b4254
--- /dev/null
+++ b/learn-you-some-erlang/tests/musicians_tests.erl
@@ -0,0 +1,56 @@
+%% WARNING: THESE TESTS TAKE A LONG TIME TO RUN
+-module(musicians_tests).
+-include_lib("eunit/include/eunit.hrl").
+-define(INSTRUMENTS, [a,b,c,d,e,f,g,h]).
+
+rand_name_test_() ->
+    {"Make sure that random names are generated",
+     {setup,
+      fun setup_many_good/0,
+      fun teardown_many/1,
+      fun test_names/1}}.
+
+eventual_crash_test_() ->
+    {"Checks that bad musicians die at some point, while"
+     "good ones don't",
+     {inparallel,
+      [{timeout, 20000, crash()},
+       {timeout, 20000, nocrash()}]}}.
+
+crash() ->
+    {ok, Pid} = musicians:start_link(drum, bad),
+    Ref = erlang:monitor(process, Pid),
+    unlink(Pid),
+    Rec = receive
+        {'DOWN', Ref, process, Pid, _R} -> ok
+        after 19000 -> timeout
+    end,
+    ?_assertEqual(ok, Rec).
+
+nocrash() ->
+    {ok, Pid} = musicians:start_link(carhorn, good),
+    Ref = erlang:monitor(process, Pid),
+    unlink(Pid),
+    Rec = receive
+        {'DOWN', Ref, process, Pid, _R} -> ok
+        after 19000 -> musicians:stop(carhorn), timeout
+    end,
+    ?_assertEqual(timeout, Rec).
+
+setup_many_good() ->
+    [element(2,musicians:start_link(X, good)) ||
+        X <- ?INSTRUMENTS].
+
+teardown_many(_) ->
+    [musicians:stop(X) || X <- ?INSTRUMENTS].
+
+test_names(Musicians) ->
+    Names = [find_name(M) || M <- Musicians],
+    SetNames = ordsets:to_list(ordsets:from_list(Names)),
+    ?_assert(2 < length(SetNames)). % totally arbitrary ratio
+
+find_name(Inst) ->
+    {status, _Pid, _, [_Dict, _Status, _Ancestor, _,
+     [_Header, _,
+      {data, [{"State", {state, Name, _, _}}]}]]} = sys:get_status(Inst),
+    Name.
diff --git a/learn-you-some-erlang/tests/oop_tests.erl b/learn-you-some-erlang/tests/oop_tests.erl
new file mode 100644
index 0000000..6ea444a
--- /dev/null
+++ b/learn-you-some-erlang/tests/oop_tests.erl
@@ -0,0 +1,16 @@
+-module(oop_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+shell_test_() ->
+    Bird = oop:animal("Bird"),
+    Dog = oop:dog("Raptor-Dog"),
+    Cat = oop:cat("Sgt. McMittens"),
+    [?_assertEqual("living thing", Bird(type)),
+     ?_assertEqual("Bird eats worm", Bird({eat, "worm"})),
+     ?_assertEqual("Raptor-Dog says: Woof!", Dog(talk)),
+     ?_assertEqual("Raptor-Dog", Dog(name)),
+     ?_assertEqual("cat", Cat(type)),
+     ?_assertEqual("Raptor-Dog chases a cat named Sgt. McMittens around",
+                   Dog({chase, Cat})),
+     ?_assertEqual("I'm sorry Dave, I can't do that.", Cat({play, "yarn"}))].
+     
diff --git a/learn-you-some-erlang/tests/records_tests.erl b/learn-you-some-erlang/tests/records_tests.erl
new file mode 100644
index 0000000..327120f
--- /dev/null
+++ b/learn-you-some-erlang/tests/records_tests.erl
@@ -0,0 +1,46 @@
+-module(records_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+first_robot_test_() ->
+    ?_assertEqual(records:first_robot(),
+        {robot, 
+         "Mechatron",
+         handmade,
+         undefined,
+         ["Moved by a small man inside"]}).
+
+car_factory_test_() ->
+    ?_assertEqual(records:car_factory("Jokeswagen"),
+                  {robot,
+                   "Jokeswagen",
+                   industrial,
+                   "building cars",
+                   []}).
+
+repairman_test_() ->
+    ?_assertEqual(records:repairman({robot,
+                                     "Ulbert",
+                                     industrial,
+                                     ["trying to have feelings"],
+                                     []}),
+                  {repaired, {robot,
+                              "Ulbert",
+                              industrial,
+                              ["trying to have feelings"],
+                              ["Repaired by repairman"]}}).
+
+admin_panel_test_() ->
+    [?_assertEqual(records:admin_panel({user, 1, "ferd", admin, 96}),
+                   "ferd is allowed!"),
+     ?_assertEqual(records:admin_panel({user, 2, "you", users, 66}),
+                   "you is not allowed")].
+
+adult_section_test_() ->
+    [?_assertEqual(records:adult_section({user, 21, "Bill", users, 72}),
+                   allowed),
+     ?_assertEqual(records:adult_section({user, 22, "Noah", users, 13}),
+                   forbidden)].
+
+included_test_() ->
+    ?_assertEqual(records:included(),
+                  {included, "Some value", "yeah!", undefined}).
diff --git a/learn-you-some-erlang/tests/recursive_tests.erl b/learn-you-some-erlang/tests/recursive_tests.erl
new file mode 100644
index 0000000..554c691
--- /dev/null
+++ b/learn-you-some-erlang/tests/recursive_tests.erl
@@ -0,0 +1,109 @@
+-module(recursive_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+%% those were not in the module, but yeah
+
+fac_test_() ->
+    [?_assert(24 == recursive:fac(4)),
+     ?_assert(1 == recursive:fac(0)),
+     ?_assert(1 == recursive:fac(1)),
+     ?_assertError(function_clause, recursive:fac(-1))].
+
+tail_fac_test_() ->
+    [?_assert(recursive:fac(4) == recursive:tail_fac(4)),
+     ?_assert(recursive:fac(0) == recursive:tail_fac(0)),
+     ?_assert(recursive:fac(1) == recursive:tail_fac(1)),
+     ?_assertError(function_clause, recursive:tail_fac(-1))].
+
+len_test_() ->
+    [?_assert(1 == recursive:len([a])),
+     ?_assert(0 == recursive:len([])),
+     ?_assert(5 == recursive:len([1,2,3,4,5]))].
+
+tail_len_test_() ->
+    [?_assert(recursive:len([a]) == recursive:tail_len([a])),
+     ?_assert(recursive:len([]) == recursive:tail_len([])),
+     ?_assert(recursive:len([1,2,3,4,5]) == recursive:tail_len([1,2,3,4,5]))].
+
+duplicate_test_() ->
+    [?_assert([] == recursive:duplicate(0,a)),
+     ?_assert([a] == recursive:duplicate(1,a)),
+     ?_assert([a,a,a] == recursive:duplicate(3,a))].
+
+tail_duplicate_test_() ->
+    [?_assert(recursive:tail_duplicate(0,a) == recursive:duplicate(0,a)),
+     ?_assert(recursive:tail_duplicate(1,a) == recursive:duplicate(1,a)),
+     ?_assert(recursive:tail_duplicate(3,a) == recursive:duplicate(3,a))].
+
+reverse_test_() ->
+    [?_assert([] == recursive:reverse([])),
+     ?_assert([1] == recursive:reverse([1])),
+     ?_assert([3,2,1] == recursive:reverse([1,2,3]))].
+
+tail_reverse_test_() ->
+    [?_assertEqual(recursive:tail_reverse([]),
+                   recursive:reverse([])),
+     ?_assertEqual(recursive:tail_reverse([1]),
+                   recursive:reverse([1])),
+     ?_assertEqual(recursive:tail_reverse([1,2,3]),
+                   recursive:reverse([1,2,3]))].
+
+sublist_test_() ->
+    [?_assert([] == recursive:sublist([1,2,3],0)),
+     ?_assert([1,2] == recursive:sublist([1,2,3],2)),
+     ?_assert([] == recursive:sublist([], 4))].
+
+tail_sublist_test_() ->
+    [?_assertEqual(recursive:tail_sublist([1,2,3],0),
+                   recursive:sublist([1,2,3],0)),
+     ?_assertEqual(recursive:tail_sublist([1,2,3],2),
+                   recursive:sublist([1,2,3],2)),
+     ?_assertEqual(recursive:tail_sublist([], 4),
+                   recursive:sublist([], 4))].
+
+zip_test_() ->
+    [?_assert([{a,1},{b,2},{c,3}] == recursive:zip([a,b,c],[1,2,3])),
+     ?_assert([] == recursive:zip([],[])),
+     ?_assertError(function_clause, recursive:zip([1],[1,2]))].
+
+lenient_zip_test_() ->
+    [?_assertEqual([{a,1},{b,2},{c,3}],
+                   recursive:lenient_zip([a,b,c],[1,2,3])),
+     ?_assert([] == recursive:lenient_zip([],[])),
+     ?_assert([{a,1}] == recursive:lenient_zip([a],[1,2]))].
+
+%% exercises!
+tail_zip_test_() ->
+    [?_assertEqual(recursive:tail_zip([a,b,c],[1,2,3]),
+                   recursive:zip([a,b,c],[1,2,3])),
+     ?_assertEqual(recursive:tail_zip([],[]),
+                   recursive:zip([],[])),
+     ?_assertError(function_clause, recursive:tail_zip([1],[1,2]))].
+
+tail_lenient_zip_test_() ->
+    [?_assertEqual(recursive:tail_lenient_zip([a,b,c],[1,2,3]),
+                   recursive:lenient_zip([a,b,c],[1,2,3])),
+     ?_assertEqual(recursive:tail_lenient_zip([],[]),
+                   recursive:lenient_zip([],[])),
+     ?_assertEqual(recursive:tail_lenient_zip([a],[1,2]),
+                   recursive:lenient_zip([a],[1,2]))].
+
+%% quick, sort!
+quicksort_test_() ->
+    [?_assert([] == recursive:quicksort([])),
+     ?_assert([1] == recursive:quicksort([1])),
+     ?_assert([1,2,2,4,6] == recursive:quicksort([4,2,6,2,1])),
+     ?_assert(" JRaceeinqqsuu" == recursive:quicksort("Jacques Requin"))].
+
+lc_quicksort_test_() ->
+    [?_assert([] == recursive:lc_quicksort([])),
+     ?_assert([1] == recursive:lc_quicksort([1])),
+     ?_assert([1,2,2,4,6] == recursive:lc_quicksort([4,2,6,2,1])),
+     ?_assert(" JRaceeinqqsuu" == recursive:lc_quicksort("Jacques Requin"))].
+    
+bestest_qsort_test_() ->
+    [?_assert([] == recursive:bestest_qsort([])),
+     ?_assert([1] == recursive:bestest_qsort([1])),
+     ?_assert([1,2,2,4,6] == recursive:bestest_qsort([4,2,6,2,1])),
+     ?_assert(" JRaceeinqqsuu" == recursive:bestest_qsort("Jacques Requin"))].
+
diff --git a/learn-you-some-erlang/tests/road_tests.erl b/learn-you-some-erlang/tests/road_tests.erl
new file mode 100644
index 0000000..e99eeff
--- /dev/null
+++ b/learn-you-some-erlang/tests/road_tests.erl
@@ -0,0 +1,33 @@
+-module(road_tests).
+-include_lib("eunit/include/eunit.hrl").
+-test_warnings([main/1]).
+
+group_vals_test_() ->
+    [?_assertEqual([{a,b,x},{a,b,x}], road:group_vals([a,b,x,a,b,x],[])),
+     ?_assertEqual([], road:group_vals([],[])),
+     ?_assertError(function_clause, road:group_vals([a,b,x,a],[]))].
+
+parse_map_test_() ->
+    [?_assertEqual([], road:parse_map("")),
+     ?_assertEqual([], road:parse_map(<<"">>)),
+     ?_assertEqual([{10,5,4}], road:parse_map("10 5 4")),
+     ?_assertEqual([{10,5,4},{1,2,3}], road:parse_map("10 5 4 1 2 3")),
+     ?_assertEqual([{10,5,4}], road:parse_map(<<"10 5 4">>)),
+     ?_assertEqual([{10,5,4}], road:parse_map("10\t5\n4")),
+     ?_assertEqual([{10,5,4},{1,2,3}],
+                   road:parse_map("10\r\n5  4 1\t\t2\r3"))].
+
+%% little testing required on this one, the optimal_path tests will
+%% do it in a hidden manner.
+shortest_step_test_() ->
+    [?_assertEqual({{1,[{a,1}]},{2,[{x,1},{a,1}]}},
+                   road:shortest_step({1,8,1},{{0,[]},{0,[]}}))].
+
+optimal_path_test_() ->
+    [?_assertEqual([{b,10},{x,30},{a,5},{x,20},{b,2},{b,8}],
+                   road:optimal_path(
+                     road:parse_map("50 10 30 5 90 20 40 2 24 10 8 0"))),
+     ?_assertEqual([{a,1},{a,1},{a,1}],
+                   road:optimal_path([{1,10,2},{1,3,3},{1,2,0}])),
+     ?_assertEqual([{a,1},{x,1},{b,1},{x,1},{a,1}],
+                   road:optimal_path([{1,3,1},{4,1,1},{1,6,1}]))].
diff --git a/learn-you-some-erlang/tests/tree_tests.erl b/learn-you-some-erlang/tests/tree_tests.erl
new file mode 100644
index 0000000..5a2633b
--- /dev/null
+++ b/learn-you-some-erlang/tests/tree_tests.erl
@@ -0,0 +1,64 @@
+-module(tree_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+empty_test() ->
+    ?assert({node, 'nil'} =:= tree:empty()).
+
+%% oh god this gets ugly
+insert_test_() ->
+    T1 = tree:insert(a, "a", tree:empty()),
+    T2 = tree:insert(c, "c", T1),
+    T3 = tree:insert(n, "n",
+         tree:insert(z, "z",
+         tree:insert(t, "t",
+         tree:insert(x, "x", T2)))),
+    [?_assertEqual(T1, {node, {a,"a",{node,nil},{node,nil}}}),
+     ?_assertEqual(T2, {node, {a,"a",
+                               {node,nil},
+                               {node, {c,"c",{node,nil},{node,nil}}}}}),
+     ?_assertEqual(T3, {node, {a,"a",
+                               {node, nil},
+                               {node, {c,"c",
+                                      {node, nil},
+                                      {node, {x,"x",
+                                             {node, {t,"t",
+                                                    {node, {n,"n",
+                                                            {node,nil},
+                                                            {node,nil}}},
+                                                    {node, nil}}},
+                                             {node, {z,"z",
+                                                    {node,nil},
+                                                    {node,nil}}}}}}}}})].
+%% not as bad!
+lookup_test_() ->
+    T = tree:insert(x, "x",
+        tree:insert(t, "t",
+        tree:insert(z, "z",
+        tree:insert(n, "n",
+        tree:insert(c, "c",
+        tree:insert(a, "a", tree:empty())))))),
+    [?_assert({ok,"t"} == tree:lookup(t,T)),
+     ?_assert(undefined == tree:lookup(21, T)),
+     ?_assert(undefined == tree:lookup(a, tree:empty()))].
+
+%% done with both insert and lookup
+update_test_() ->
+    T1 = tree:insert(x, "x",
+         tree:insert(t, "t",
+         tree:insert(z, "z",
+         tree:insert(n, "n",
+         tree:insert(c, "c",
+         tree:insert(a, "a", tree:empty())))))),
+    T2 = tree:insert(x, "X", T1),
+    [?_assertEqual({ok, "x"}, tree:lookup(x, T1)),
+     ?_assertEqual({ok, "X"}, tree:lookup(x, T2))].
+
+has_value_test_() ->
+    T1 = tree:insert(x, "x",
+         tree:insert(t, "t",
+         tree:insert(z, "z",
+         tree:insert(n, "n",
+         tree:insert(c, "c",
+         tree:insert(a, "a", tree:empty())))))), 
+    [?_assertEqual(true, tree:has_value("z", T1)),
+     ?_assertEqual(false,tree:has_value("Z", T1))].
diff --git a/learn-you-some-erlang/tests/useless_tests.erl b/learn-you-some-erlang/tests/useless_tests.erl
new file mode 100644
index 0000000..8f174be
--- /dev/null
+++ b/learn-you-some-erlang/tests/useless_tests.erl
@@ -0,0 +1,18 @@
+-module(useless_tests).
+-include_lib("eunit/include/eunit.hrl").
+-test_warnings([hello_test/0]).
+
+add_test_() ->
+    [?_assertEqual(-5, useless:add(-3, -2)),
+     ?_assertEqual(4, useless:add(2, 2)),
+     ?_assertEqual(2.5, useless:add(2.0, 0.5)),
+     ?_assertEqual(1, useless:add(-3, 4))].
+
+hello_test() ->
+    ok. % no test possible for I/O. Curse you, side effects!
+
+greet_and_add_test_() ->
+    [?_assertEqual(useless:greet_and_add_two(-3), useless:add(-3, 2)),
+     ?_assertEqual(useless:greet_and_add_two(2), useless:add(2, 2)),
+     ?_assertEqual(useless:greet_and_add_two(0.5), useless:add(2, 0.5)),
+     ?_assertEqual(useless:greet_and_add_two(-3), useless:add(-3, 2))].
diff --git a/learn-you-some-erlang/tests/what_the_if_tests.erl b/learn-you-some-erlang/tests/what_the_if_tests.erl
new file mode 100644
index 0000000..13465e9
--- /dev/null
+++ b/learn-you-some-erlang/tests/what_the_if_tests.erl
@@ -0,0 +1,17 @@
+-module(what_the_if_tests).
+-include_lib("eunit/include/eunit.hrl").
+
+heh_fine_test() ->
+    ?assertException(error, if_clause, what_the_if:heh_fine()).
+
+oh_god_test_() ->
+    [?_assertEqual(might_succeed, what_the_if:oh_god(2)),
+     ?_assertEqual(always_does, what_the_if:oh_god(3))].
+
+help_me_test_() ->
+    [?_assertEqual({cat, "says meow!"}, what_the_if:help_me(cat)),
+     ?_assertEqual({beef, "says mooo!"}, what_the_if:help_me(beef)),
+     ?_assertEqual({dog, "says bark!"}, what_the_if:help_me(dog)),
+     ?_assertEqual({tree, "says bark!"}, what_the_if:help_me(tree)),
+     ?_assertEqual({"other", "says fgdadfgna!"}, what_the_if:help_me("other")),
+     ?_assertEqual({5, "says fgdadfgna!"}, what_the_if:help_me(5))].
diff --git a/learn-you-some-erlang/trade/trade_calls.erl b/learn-you-some-erlang/trade/trade_calls.erl
new file mode 100644
index 0000000..e72c891
--- /dev/null
+++ b/learn-you-some-erlang/trade/trade_calls.erl
@@ -0,0 +1,144 @@
+-module(trade_calls).
+-compile(export_all).
+
+%% test a little bit of everything and also deadlocks on ready state
+%% -- leftover messages possible on race conditions on ready state
+main_ab() ->
+    S = self(),
+    PidCliA = spawn(fun() -> a(S) end),
+    receive PidA -> PidA end,
+    spawn(fun() -> b(PidA, PidCliA) end).
+
+a(Parent) ->
+    {ok, Pid} = trade_fsm:start_link("Carl"),
+    Parent ! Pid,
+    io:format("Spawned Carl: ~p~n", [Pid]),
+    %sys:trace(Pid,true),
+    timer:sleep(800),
+    trade_fsm:accept_trade(Pid),
+    timer:sleep(400),
+    io:format("~p~n",[trade_fsm:ready(Pid)]),
+    timer:sleep(1000),
+    trade_fsm:make_offer(Pid, "horse"),
+    trade_fsm:make_offer(Pid, "sword"),
+    timer:sleep(1000),
+    io:format("a synchronizing~n"),
+    sync2(),
+    trade_fsm:ready(Pid),
+    timer:sleep(200),
+    trade_fsm:ready(Pid),
+    timer:sleep(1000).
+
+b(PidA, PidCliA) ->
+    {ok, Pid} = trade_fsm:start_link("Jim"),
+    io:format("Spawned Jim: ~p~n", [Pid]),
+    %sys:trace(Pid,true),
+    timer:sleep(500),
+    trade_fsm:trade(Pid, PidA),
+    trade_fsm:make_offer(Pid, "boots"),
+    timer:sleep(200),
+    trade_fsm:retract_offer(Pid, "boots"),
+    timer:sleep(500),
+    trade_fsm:make_offer(Pid, "shotgun"),
+    timer:sleep(1000),
+    io:format("b synchronizing~n"),
+    sync1(PidCliA),
+    trade_fsm:make_offer(Pid, "horse"), %% race condition!
+    trade_fsm:ready(Pid),
+    timer:sleep(200),
+    timer:sleep(1000).
+
+%% force a race condition on cd trade negotiation
+main_cd() ->
+    S = self(),
+    PidCliC = spawn(fun() -> c(S) end),
+    receive PidC -> PidC end,
+    spawn(fun() -> d(S, PidC, PidCliC) end),
+    receive PidD -> PidD end,
+    PidCliC ! PidD.
+    
+c(Parent) ->
+    {ok, Pid} = trade_fsm:start_link("Marc"),
+    Parent ! Pid,
+    receive PidD -> PidD end,
+    io:format("Spawned Marc: ~p~n", [Pid]),
+    %sys:trace(Pid, true),
+    sync2(),
+    trade_fsm:trade(Pid, PidD),
+    %% no need to accept_trade thanks to the race condition
+    timer:sleep(200),
+    trade_fsm:retract_offer(Pid, "car"),
+    trade_fsm:make_offer(Pid, "horse"),
+    timer:sleep(600),
+    trade_fsm:cancel(Pid),
+    timer:sleep(1000).
+
+d(Parent, PidC, PidCliC) ->
+    {ok, Pid} = trade_fsm:start_link("Pete"),
+    Parent ! Pid,
+    io:format("Spawned Jim: ~p~n", [Pid]),
+    %sys:trace(Pid,true),
+    sync1(PidCliC),
+    trade_fsm:trade(Pid, PidC),
+    %% no need to accept_trade thanks to the race condition
+    timer:sleep(200),
+    trade_fsm:retract_offer(Pid, "car"),
+    trade_fsm:make_offer(Pid, "manatee"),
+    timer:sleep(100),
+    trade_fsm:ready(Pid),
+    timer:sleep(1000).
+
+main_ef() ->
+    S = self(),
+    PidCliE = spawn(fun() -> e(S) end),
+    receive PidE -> PidE end,
+    spawn(fun() -> f(PidE, PidCliE) end).
+
+e(Parent) ->
+    {ok, Pid} = trade_fsm:start_link("Carl"),
+    Parent ! Pid,
+    io:format("Spawned Carl: ~p~n", [Pid]),
+    %sys:trace(Pid,true),
+    timer:sleep(800),
+    trade_fsm:accept_trade(Pid),
+    timer:sleep(400),
+    io:format("~p~n",[trade_fsm:ready(Pid)]),
+    timer:sleep(1000),
+    trade_fsm:make_offer(Pid, "horse"),
+    trade_fsm:make_offer(Pid, "sword"),
+    timer:sleep(1000),
+    io:format("a synchronizing~n"),
+    sync2(),
+    trade_fsm:ready(Pid),
+    timer:sleep(200),
+    trade_fsm:ready(Pid),
+    timer:sleep(1000).
+
+f(PidE, PidCliE) ->
+    {ok, Pid} = trade_fsm:start_link("Jim"),
+    io:format("Spawned Jim: ~p~n", [Pid]),
+    %sys:trace(Pid,true),
+    timer:sleep(500),
+    trade_fsm:trade(Pid, PidE),
+    trade_fsm:make_offer(Pid, "boots"),
+    timer:sleep(200),
+    trade_fsm:retract_offer(Pid, "boots"),
+    timer:sleep(500),
+    trade_fsm:make_offer(Pid, "shotgun"),
+    timer:sleep(1000),
+    io:format("b synchronizing~n"),
+    sync1(PidCliE),
+    trade_fsm:make_offer(Pid, "horse"),
+    timer:sleep(200),
+    trade_fsm:ready(Pid),
+    timer:sleep(1000).
+
+%%% Utils
+sync1(Pid) ->
+    Pid ! self(),
+    receive ack -> ok end.
+
+sync2() ->
+    receive
+        From -> From ! ack
+    end.
diff --git a/learn-you-some-erlang/trade/trade_fsm.erl b/learn-you-some-erlang/trade/trade_fsm.erl
new file mode 100644
index 0000000..fc66870
--- /dev/null
+++ b/learn-you-some-erlang/trade/trade_fsm.erl
@@ -0,0 +1,359 @@
+-module(trade_fsm).
+-behaviour(gen_fsm).
+
+%% public API
+-export([start/1, start_link/1, trade/2, accept_trade/1, 
+         make_offer/2, retract_offer/2, ready/1, cancel/1]).
+%% gen_fsm callbacks
+-export([init/1, handle_event/3, handle_sync_event/4, handle_info/3,
+         terminate/3, code_change/4,
+         % custom state names
+         idle/2, idle/3, idle_wait/2, idle_wait/3, negotiate/2,
+         negotiate/3, wait/2, ready/2, ready/3]).
+
+-record(state, {name="",
+                other,
+                ownitems=[],
+                otheritems=[],
+                monitor,
+                from}).
+
+%%% PUBLIC API
+start(Name) ->
+    gen_fsm:start(?MODULE, [Name], []).
+
+start_link(Name) ->
+    gen_fsm:start_link(?MODULE, [Name], []).
+
+%% ask for a begin session. Returns when/if the other accepts
+trade(OwnPid, OtherPid) ->
+    gen_fsm:sync_send_event(OwnPid, {negotiate, OtherPid}, 30000).
+
+%% Accept someone's trade offer.
+accept_trade(OwnPid) ->
+    gen_fsm:sync_send_event(OwnPid, accept_negotiate).
+
+%% Send an item on the table to be traded
+make_offer(OwnPid, Item) ->
+    gen_fsm:send_event(OwnPid, {make_offer, Item}).
+
+%% Cancel trade offer
+retract_offer(OwnPid, Item) ->
+    gen_fsm:send_event(OwnPid, {retract_offer, Item}).
+
+%% Mention that you're ready for a trade. When the other
+%% player also declares being ready, the trade is done
+ready(OwnPid) ->
+    gen_fsm:sync_send_event(OwnPid, ready, infinity).
+
+%% Cancel the transaction.
+cancel(OwnPid) ->
+    gen_fsm:sync_send_all_state_event(OwnPid, cancel).
+
+%%% CLIENT-TO-CLIENT API
+%% These calls are only listed for the gen_fsm to call
+%% among themselves
+%% All calls are asynchronous to avoid deadlocks
+
+%% Ask the other FSM for a trade session
+ask_negotiate(OtherPid, OwnPid) ->
+    gen_fsm:send_event(OtherPid, {ask_negotiate, OwnPid}).
+
+%% Forward the client message accepting the transaction
+accept_negotiate(OtherPid, OwnPid) ->
+    gen_fsm:send_event(OtherPid, {accept_negotiate, OwnPid}).
+
+%% forward a client's offer
+do_offer(OtherPid, Item) ->
+    gen_fsm:send_event(OtherPid, {do_offer, Item}).
+
+%% forward a client's offer cancellation
+undo_offer(OtherPid, Item) ->
+    gen_fsm:send_event(OtherPid, {undo_offer, Item}).
+
+%% Ask the other side if he's ready to trade.
+are_you_ready(OtherPid) ->
+    gen_fsm:send_event(OtherPid, are_you_ready).
+
+%% Reply that the side is not ready to trade
+%% i.e. is not in 'wait' state.
+not_yet(OtherPid) ->
+    gen_fsm:send_event(OtherPid, not_yet).
+
+%% Tells the other fsm that the user is currently waiting
+%% for the ready state. State should transition to 'ready'
+am_ready(OtherPid) ->
+    gen_fsm:send_event(OtherPid, 'ready!').
+
+%% Acknowledge that the fsm is in a ready state.
+ack_trans(OtherPid) ->
+    gen_fsm:send_event(OtherPid, ack).
+
+%% ask if ready to commit
+ask_commit(OtherPid) ->
+    gen_fsm:sync_send_event(OtherPid, ask_commit).
+
+%% begin the synchronous commit
+do_commit(OtherPid) ->
+    gen_fsm:sync_send_event(OtherPid, do_commit).
+
+%% Make the other FSM aware that your client cancelled the trade
+notify_cancel(OtherPid) ->
+    gen_fsm:send_all_state_event(OtherPid, cancel).
+
+%%% GEN_FSM API
+init(Name) ->
+    {ok, idle, #state{name=Name}}. 
+
+
+%% idle state is the state before any trade is done.
+%% The other player asks for a negotiation. We basically
+%% only wait for our own user to accept the trade,
+%% and store the other's Pid for future uses
+idle({ask_negotiate, OtherPid}, S=#state{}) ->
+    Ref = monitor(process, OtherPid),
+    notice(S, "~p asked for a trade negotiation", [OtherPid]),
+    {next_state, idle_wait, S#state{other=OtherPid, monitor=Ref}};
+idle(Event, Data) ->
+    unexpected(Event, idle),
+    {next_state, idle, Data}.
+
+%% trade call coming from the user. Forward to the other side,
+%% forward it and store the other's Pid
+idle({negotiate, OtherPid}, From, S=#state{}) ->
+    ask_negotiate(OtherPid, self()),
+    notice(S, "asking user ~p for a trade", [OtherPid]),
+    Ref = monitor(process, OtherPid),
+    {next_state, idle_wait, S#state{other=OtherPid, monitor=Ref, from=From}};
+idle(Event, _From, Data) ->
+    unexpected(Event, idle),
+    {next_state, idle, Data}.
+
+%% idle_wait allows to expect replies from the other side and
+%% start negotiating for items
+
+%% the other side asked for a negotiation while we asked for it too.
+%% this means both definitely agree to the idea of doing a trade.
+%% Both sides can assume the other feels the same!
+idle_wait({ask_negotiate, OtherPid}, S=#state{other=OtherPid}) ->
+    gen_fsm:reply(S#state.from, ok),
+    notice(S, "starting negotiation", []),
+    {next_state, negotiate, S};
+%% The other side has accepted our offer. Move to negotiate state
+idle_wait({accept_negotiate, OtherPid}, S=#state{other=OtherPid}) ->
+    gen_fsm:reply(S#state.from, ok),
+    notice(S, "starting negotiation", []),
+    {next_state, negotiate, S};
+%% different call from someone else. Not supported! Let it die.
+idle_wait(Event, Data) ->
+    unexpected(Event, idle_wait),
+    {next_state, idle_wait, Data}.
+
+%% Our own client has decided to accept the transaction.
+%% Make the other FSM aware of it and move to negotiate state.
+idle_wait(accept_negotiate, _From, S=#state{other=OtherPid}) ->
+    accept_negotiate(OtherPid, self()),
+    notice(S, "accepting negotiation", []),
+    {reply, ok, negotiate, S};
+idle_wait(Event, _From, Data) ->
+    unexpected(Event, idle_wait),
+    {next_state, idle_wait, Data}.
+
+%% own side offering an item
+negotiate({make_offer, Item}, S=#state{ownitems=OwnItems}) ->
+    do_offer(S#state.other, Item),
+    notice(S, "offering ~p", [Item]),
+    {next_state, negotiate, S#state{ownitems=add(Item, OwnItems)}};
+%% Own side retracting an item offer
+negotiate({retract_offer, Item}, S=#state{ownitems=OwnItems}) ->
+    undo_offer(S#state.other, Item),
+    notice(S, "cancelling offer on ~p", [Item]),
+    {next_state, negotiate, S#state{ownitems=remove(Item, OwnItems)}};
+%% other side offering an item
+negotiate({do_offer, Item}, S=#state{otheritems=OtherItems}) ->
+    notice(S, "other player offering ~p", [Item]),
+    {next_state, negotiate, S#state{otheritems=add(Item, OtherItems)}};
+%% other side retracting an item offer
+negotiate({undo_offer, Item}, S=#state{otheritems=OtherItems}) ->
+    notice(S, "Other player cancelling offer on ~p", [Item]),
+    {next_state, negotiate, S#state{otheritems=remove(Item, OtherItems)}};
+%% Other side has declared itself ready. Our own FSM should tell it to
+%% wait (with not_yet/1).
+negotiate(are_you_ready, S=#state{other=OtherPid}) ->
+    io:format("Other user ready to trade.~n"),
+    notice(S,
+           "Other user ready to transfer goods:~n"
+           "You get ~p, The other side gets ~p",
+           [S#state.otheritems, S#state.ownitems]),
+    not_yet(OtherPid),
+    {next_state, negotiate, S};
+negotiate(Event, Data) ->
+    unexpected(Event, negotiate),
+    {next_state, negotiate, Data}.
+
+%% own user mentioning he is ready. Next state should be wait
+%% and we add the 'from' to the state so we can reply to the
+%% user once ready.
+negotiate(ready, From, S = #state{other=OtherPid}) ->
+    are_you_ready(OtherPid),
+    notice(S, "asking if ready, waiting", []),
+    {next_state, wait, S#state{from=From}};
+negotiate(Event, _From, S) ->
+    unexpected(Event, negotiate),
+    {next_state, negotiate, S}.
+
+%% other side offering an item. Don't forget our client is still
+%% waiting for a reply, so let's tell them the trade state changed
+%% and move back to the negotiate state
+wait({do_offer, Item}, S=#state{otheritems=OtherItems}) ->
+    gen_fsm:reply(S#state.from, offer_changed),
+    notice(S, "other side offering ~p", [Item]),
+    {next_state, negotiate, S#state{otheritems=add(Item, OtherItems)}};
+%% other side cancelling an item offer. Don't forget our client is still
+%% waiting for a reply, so let's tell them the trade state changed
+%% and move back to the negotiate state
+wait({undo_offer, Item}, S=#state{otheritems=OtherItems}) ->
+    gen_fsm:reply(S#state.from, offer_changed),
+    notice(S, "Other side cancelling offer of ~p", [Item]),
+    {next_state, negotiate, S#state{otheritems=remove(Item, OtherItems)}};
+%% The other client falls in ready state and asks us about it.
+%% However, the other client could have moved out of wait state already.
+%% Because of this, we send that we indeed are 'ready!' and hope for them
+%% to do the same.
+wait(are_you_ready, S=#state{}) ->
+    am_ready(S#state.other),
+    notice(S, "asked if ready, and I am. Waiting for same reply", []),
+    {next_state, wait, S};
+%% The other client is not ready to trade yet. We keep waiting
+%% and won't reply to our own client yet.
+wait(not_yet, S = #state{}) ->
+    notice(S, "Other not ready yet", []),
+    {next_state, wait, S};
+%% The other client was waiting for us! Let's reply to ours and
+%% send the ack message for the commit initiation on the other end.
+%% We can't go back after this.
+wait('ready!', S=#state{}) ->
+    am_ready(S#state.other),
+    ack_trans(S#state.other),
+    gen_fsm:reply(S#state.from, ok),
+    notice(S, "other side is ready. Moving to ready state", []),
+    {next_state, ready, S};
+wait(Event, Data) ->
+    unexpected(Event, wait),
+    {next_state, wait, Data}.
+
+%% Ready state with the acknowledgement message coming from the
+%% other side. We determine if we should begin the synchronous
+%% commit or if the other side should.
+%% A successful commit (if we initiated it) could be done
+%% in the terminate function or any other before.
+ready(ack, S=#state{}) ->
+    case priority(self(), S#state.other) of
+        true ->
+            try 
+                notice(S, "asking for commit", []),
+                ready_commit = ask_commit(S#state.other),
+                notice(S, "ordering commit", []),
+                ok = do_commit(S#state.other),
+                notice(S, "committing...", []),
+                commit(S),
+                {stop, normal, S}
+            catch Class:Reason -> 
+                %% abort! Either ready_commit or do_commit failed
+                notice(S, "commit failed", []),
+                {stop, {Class, Reason}, S}
+            end;
+        false ->
+            {next_state, ready, S}
+    end;
+ready(Event, Data) ->
+    unexpected(Event, ready),
+    {next_state, ready, Data}.
+
+%% We weren't the ones to initiate the commit.
+%% Let's reply to the other side to say we're doing our part
+%% and terminate.
+ready(ask_commit, _From, S) ->
+    notice(S, "replying to ask_commit", []),
+    {reply, ready_commit, ready, S};
+ready(do_commit, _From, S) ->
+    notice(S, "committing...", []),
+    commit(S),
+    {stop, normal, ok, S};
+ready(Event, _From, Data) ->
+    unexpected(Event, ready),
+    {next_state, ready, Data}.
+
+%% This cancel event has been sent by the other player
+%% stop whatever we're doing and shut down!
+handle_event(cancel, _StateName, S=#state{}) ->
+    notice(S, "received cancel event", []),
+    {stop, other_cancelled, S};
+handle_event(Event, StateName, Data) ->
+    unexpected(Event, StateName),
+    {next_state, StateName, Data}.
+
+%% This cancel event comes from the client. We must warn the other
+%% player that we have a quitter!
+handle_sync_event(cancel, _From, _StateName, S = #state{}) ->
+    notify_cancel(S#state.other),
+    notice(S, "cancelling trade, sending cancel event", []),
+    {stop, cancelled, ok, S};
+%% Note: DO NOT reply to unexpected calls. Let the call-maker crash!
+handle_sync_event(Event, _From, StateName, Data) ->
+    unexpected(Event, StateName),
+    {next_state, StateName, Data}.
+
+%% The other player's FSM has gone down. We have
+%% to abort the trade. 
+handle_info({'DOWN', Ref, process, Pid, Reason}, _, S=#state{other=Pid, monitor=Ref}) ->
+    notice(S, "Other side dead", []),
+    {stop, {other_down, Reason}, S};
+handle_info(Info, StateName, Data) ->
+    unexpected(Info, StateName),
+    {next_state, StateName, Data}.
+
+code_change(_OldVsn, StateName, Data, _Extra) ->
+ {ok, StateName, Data}.
+
+%% Transaction completed.
+terminate(normal, ready, S=#state{}) ->
+    notice(S, "FSM leaving.", []);
+terminate(_Reason, _StateName, _StateData) ->
+    ok.
+
+%%% PRIVATE FUNCTIONS
+
+%% adds an item to an item list
+add(Item, Items) ->
+    [Item | Items].
+
+%% remove an item from an item list
+remove(Item, Items) ->
+    Items -- [Item].
+
+%% Send players a notice. This could be messages to their clients
+%% but for our purposes, outputting to the shell is enough.
+notice(#state{name=N}, Str, Args) ->
+    io:format("~s: "++Str++"~n", [N|Args]).
+
+%% Unexpected allows to log unexpected messages
+unexpected(Msg, State) ->
+    io:format("~p received unknown event ~p while in state ~p~n",
+              [self(), Msg, State]).
+
+%% This function allows two processes to make a synchronous call to each
+%% other by electing one Pid to do it. Both processes call it and it
+%% tells them whether they should initiate the call or not.
+%% This is done by knowing that Erlang will alwys sort Pids in an
+%% absolute manner depending on when and where they were spawned.
+priority(OwnPid, OtherPid) when OwnPid > OtherPid -> true;
+priority(OwnPid, OtherPid) when OwnPid < OtherPid -> false.    
+
+commit(S = #state{}) ->
+    io:format("Transaction completed for ~s. "
+              "Items sent are:~n~p,~n received are:~n~p.~n"
+              "This operation should have some atomic save "
+              "in a database.~n",
+              [S#state.name, S#state.ownitems, S#state.otheritems]).
+
diff --git a/learn-you-some-erlang/tree.erl b/learn-you-some-erlang/tree.erl
new file mode 100644
index 0000000..3cda7c3
--- /dev/null
+++ b/learn-you-some-erlang/tree.erl
@@ -0,0 +1,43 @@
+-module(tree).
+-export([empty/0, insert/3, lookup/2, has_value/2]).
+
+empty() -> {node, 'nil'}.
+
+insert(Key, Val, {node, 'nil'}) ->
+    {node, {Key, Val, {node, 'nil'}, {node, 'nil'}}};
+insert(NewKey, NewVal, {node, {Key, Val, Smaller, Larger}}) when NewKey < Key ->
+    {node, {Key, Val, insert(NewKey, NewVal, Smaller), Larger}};
+insert(NewKey, NewVal, {node, {Key, Val, Smaller, Larger}}) when NewKey > Key ->
+    {node, {Key, Val, Smaller, insert(NewKey, NewVal, Larger)}};
+insert(Key, Val, {node, {Key, _, Smaller, Larger}}) ->
+    {node, {Key, Val, Smaller, Larger}}.
+
+lookup(_, {node, 'nil'}) ->
+    undefined;
+lookup(Key, {node, {Key, Val, _, _}}) ->
+    {ok, Val};
+lookup(Key, {node, {NodeKey, _, Smaller, _}}) when Key < NodeKey ->
+    lookup(Key, Smaller);
+lookup(Key, {node, {_, _, _, Larger}}) ->
+    lookup(Key, Larger).
+
+%%---------------------------------------------------------
+%% The code after this comment is added in the errors and
+%% exceptions chapter. Ignore it if you're still reading
+%% the chapter about recursion.
+%%---------------------------------------------------------
+
+has_value(Val, Tree) -> 
+    try has_value1(Val, Tree) of
+        _ -> false
+    catch
+        true -> true
+    end.
+
+has_value1(_, {node, 'nil'}) ->
+    false;
+has_value1(Val, {node, {_, Val, _, _}}) ->
+    throw(true);
+has_value1(Val, {node, {_, _, Left, Right}}) ->
+    has_value1(Val, Left),
+    has_value1(Val, Right).
diff --git a/learn-you-some-erlang/useless.erl b/learn-you-some-erlang/useless.erl
new file mode 100644
index 0000000..d5542a2
--- /dev/null
+++ b/learn-you-some-erlang/useless.erl
@@ -0,0 +1,14 @@
+-module(useless).
+-export([add/2, hello/0, greet_and_add_two/1]).
+
+add(A,B) ->
+    A + B.
+
+%% Shows greetings.
+%% io:format/1 is the standard function used to output text.
+hello() ->
+    io:format("Hello, world!~n").
+	
+greet_and_add_two(X) ->
+    hello(),
+    add(X,2).
diff --git a/learn-you-some-erlang/what_the_if.erl b/learn-you-some-erlang/what_the_if.erl
new file mode 100644
index 0000000..723c818
--- /dev/null
+++ b/learn-you-some-erlang/what_the_if.erl
@@ -0,0 +1,30 @@
+-module(what_the_if).
+-export([heh_fine/0, oh_god/1, help_me/1]).
+
+%% should check if this actually works (hint: an error will be thrown)
+heh_fine() ->
+    if 1 =:= 1 ->
+        works
+    end,
+    if 1 =:= 2; 1 =:= 1 ->
+        works
+    end,
+    if 1 =:= 2, 1 =:= 1 ->
+        fails
+    end.
+
+oh_god(N) ->
+    if N =:= 2 -> might_succeed;
+       true -> always_does  %% this is Erlang's if's 'else!'
+    end.
+
+%% note, this one would be better as a pattern match in function heads!
+%% I'm doing it this way for the sake of the example.
+help_me(Animal) ->
+    Talk = if Animal == cat  -> "meow";
+              Animal == beef -> "mooo";
+              Animal == dog  -> "bark";
+              Animal == tree -> "bark";
+              true -> "fgdadfgna"
+           end,
+    {Animal, "says " ++ Talk ++ "!"}.
diff --git a/learn-you-some-erlang/zoo.erl b/learn-you-some-erlang/zoo.erl
new file mode 100644
index 0000000..1e3c2eb
--- /dev/null
+++ b/learn-you-some-erlang/zoo.erl
@@ -0,0 +1,45 @@
+-module(zoo).
+-export([main/0]).
+
+-type red_panda() :: bamboo | birds | eggs | berries.
+-type squid() :: sperm_whale.
+-type food(A) :: fun(() -> A).
+
+-spec feeder(red_panda) -> food(red_panda());
+            (squid) -> food(squid()).
+feeder(red_panda) ->
+    fun() ->
+        element(random:uniform(4), {bamboo, birds, eggs, berries})
+    end;
+feeder(squid) ->
+    fun() -> sperm_whale end.
+
+-spec feed_red_panda(food(red_panda())) -> red_panda().
+feed_red_panda(Generator) ->
+    Food = Generator(),
+    io:format("feeding ~p to the red panda~n", [Food]),
+    Food.
+
+-spec feed_squid(food(squid())) -> squid().
+feed_squid(Generator) ->
+    Food = Generator(),
+    io:format("feeding ~p to the squid~n", [Food]),
+    Food.
+
+main() ->
+    %% Random seeding
+    <<A:32, B:32, C:32>> = crypto:rand_bytes(12),
+    random:seed(A, B, C),
+    %% The zoo buys a feeder for both the red panda and squid
+    FeederRP = feeder(red_panda),
+    FeederSquid = feeder(squid),
+    %% Time to feed them! If we do it correctly at least once,
+    %% Then no warning ever happens. Comment the two lines
+    %% below to enable dialyzer figuring stuff out! This is likely
+    %% failing because Dialyzer sees both calls as valid and thus
+    %% needs not to reevaluate them again.
+    %feed_squid(FeederSquid),
+    %feed_red_panda(FeederRP),
+    %% This should not be right!
+    feed_squid(FeederRP),
+    feed_red_panda(FeederSquid).