Processes exiting normally - erlang

Question

Given two linked processes child and parent, how does process child detect that parent exits (terminates) normally?
I, as an absolute Erlang beginner, thought that a process, when it has nothing else to do, exited using exit(normal). This then signals all linked processes, where
the behaviour of processes that have trap_exit set to false is to ignore the signal, and
the behaviour of processes that have trap_exit set to true is to generate the message {'EXIT', pid, normal} where pid is the process id of the terminating process.
My reason for thinking this is Learn You Some Erlang for Great Good and the Erlang documentation which states the following.
A process is said to terminate normally, if the exit reason is the atom normal. A process with no more code to execute terminates normally.
Apparently that is wrong (?), because exit(normal) shows ** exception exit: normal in the command prompt and makes the code below work. Exiting because there is no more code to execute does not generate the exception and does not make my code work.
As an example, consider the following code.
-module(test).
-export([start/0,test/0]).
start() ->
io:format("Parent (~p): started!\n",[self()]),
P = spawn_link(?MODULE,test,[]),
io:format(
"Parent (~p): child ~p spawned. Waiting for 5 seconds\n",[self(),P]),
timer:sleep(5000),
io:format("Parent (~p): dies out of boredom\n",[self()]),
ok.
test() ->
io:format("Child (~p): I'm... alive!\n",[self()]),
process_flag(trap_exit, true),
loop().
loop() ->
receive
Q = {'EXIT',_,_} ->
io:format("Child process died together with parent (~p)\n",[Q]);
Q ->
io:format("Something else happened... (~p)\n",[Q])
after
2000 -> io:format("Child (~p): still alive...\n", [self()]), loop()
end.
This produces output as follows.
(erlide#127.0.0.1)> test:start().
Parent (<0.145.0>): started!
Parent (<0.145.0>): child <0.176.0> spawned. Waiting for 5 seconds
Child (<0.176.0>): I'm... alive!
Child (<0.176.0>): still alive...
Child (<0.176.0>): still alive...
Parent (<0.145.0>): dies out of boredom
ok
(erlide#127.0.0.1)10> Child (<0.176.0>): still alive...
Child (<0.176.0>): still alive...
Child (<0.176.0>): still alive...
Child (<0.176.0>): still alive...
Child (<0.176.0>): still alive...
Child (<0.176.0>): still alive...
Child (<0.176.0>): still alive...
exit(pid(0,176,0),something).
Child process died together with parent ({'EXIT',<0.194.0>,something})
If had to manually execute the exit(pid(0,176,0),something) command to keep the child from staying alive forever.
Changing ok. in start to exit(normal) makes the execution go like this
(erlide#127.0.0.1)3> test:start().
Parent (<0.88.0>): started!
Parent (<0.88.0>): child <0.114.0> spawned. Waiting for 5 seconds
Child (<0.114.0>): I'm... alive!
Child (<0.114.0>): still alive...
Child (<0.114.0>): still alive...
Parent (<0.88.0>): dies out of boredom
Child process died together with parent ({'EXIT',<0.88.0>,normal})
** exception exit: normal
My concrete questions are the following.
How can I make the above code work as expected. That is, how can I make sure the child process dies together with the parent process without changing the parent process?
Why does exit(normal) generate a ** exception exit: normal in the CLI? It is hard for me to think of an exception as something that is normal. What does the scentence in the Erlang documentation mean?
I think these must be extremely basic questions, but I can't seem to figure this out....
I am using Erlang 5.9.3.1 on Windows (x64).

Answer 1

Erlang shell has the worker for evaluating commands as a separate process, and all commands you type run by the same process. When you your start function finished, worker still alive, and when you kill it by exit(), shell understand as worker exception (because worker will never die in normal case).
So:
You should run start as separate process by spawn or spawn_link
CLI logs all worker exits as exception and normal too
P.S. sorry for my english
P.P.S. spawn(fun() -> test:start() end). works as expected
4> spawn(fun() -> test:start() end).
Parent (<0.41.0>): started!
<0.41.0>
Parent (<0.41.0>): child <0.42.0> spawned. Waiting for 5 seconds
Child (<0.42.0>): I'm... alive!
Child (<0.42.0>): still alive...
Child (<0.42.0>): still alive...
Parent (<0.41.0>): dies out of boredom
Child process died together with parent ({'EXIT',<0.41.0>,normal})

Answer 2

A comment to your question on #PetrKozorezov 's answer. The shell is not behaving specially in any way. The shell worker process is just a normal process so if any process to which it is linked crashes then it will also crash. Another worker process will then be started. This is the normal Erlang way.
Your start/0 function just returns and does NOT terminate its process, it just outputs the "dying of boredom" message. That is why the loop keeps on going, it doesn't get an exit signal because no process has died.
When you change the start/0 function to end with exit(normal) then you do terminate the shell process so an exit signal is sent to the loop process which then gets the {'EXIT',...,...} message and dies.
When #PetrKozorezov spawned your original start/0 function in a separate process which then died after executing start/0 it sent an exit normal signal to the loop process which caused it to die.
This is perfectly normal Erlang behaviour and style. You would normally not end a start function with an exit but leave it up to the caller to decide when to die.
One more small point: as the start function does a spawn_link you would normally call it start_link instead. A start function is assumed to just spawn a process. This is, of course, just a convention, but a common one, so you have not made an error.