Erlang newbie: why do I have to restart to load new code

Question

I am trying to write a first program in Erlang that effects message communication between a client and server. In theory the server exits when it receives no message from the client, but every time I edit the client code and run the server again, it executes the old code. I have to ^G>q>erl>[re-enter command] to get it to see the new code.

-module(srvEsOne).

%%
%% export functions
%%

-export([start/0]).

%%function definition

start()->
    io:format("Server: Starting at pid: ~p \n",[self()]),
    case lists:member(serverEsOne, registered()) of
        true ->
            unregister(serverEsOne);                            %if the token  is present, remove it
        false ->
            ok
    end,
    register(serverEsOne,self()),
    Pid = spawn(esOne, start,[self()]),
    loop(false, false,Pid).

%
loop(Prec, Nrec,Pd)->
    io:format("Server: I am waiting to hear from: ~p \n",[Pd]),
    case Prec of
        true ->
            case Nrec of
                true ->     
                    io:format("Server: I reply to ~p \n",[Pd]),
                    Pd ! {reply, self()},
                    io:format("Server: I quit \n",[]),
                    ok;
                false ->
                    receiveLoop(Prec,Nrec,Pd)
            end;
        false ->
            receiveLoop(Prec,Nrec,Pd)
    end.

receiveLoop(Prec,Nrec,Pid) ->
    receive
        {onPid, Pid}->
            io:format("Server: I received a message to my pid from ~p \n",[Pid]),
            loop(true, Nrec,Pid);
        {onName,Pid}->
            io:format("Server: I received a message to name from ~p \n",[Pid]),
            loop(Prec,true,Pid)
    after
        5000->
            io:format("Server: I received no messages, i quit\n",[]),
            ok
    end.

And the client code reads

-module(esOne).

-export([start/1, func/1]).

start(Par) ->
    io:format("Client: I am ~p, i was spawned by the server: ~p \n",[self(),Par]),

    spawn(esOne, func, [self()]),
    io:format("Client: Now I will try to send a message to: ~p \n",[Par]),
    Par ! {self(), hotbelgo},
    serverEsOne ! {self(), hotbelgo},

    ok.



func(Parent)->
    io:format("Child: I am ~p, i was spawned from ~p \n",[self(),Parent]).

The server is failing to receive a message from the client, but I can't sensibly begin to debug that until I can try changes to the code in a more straightforward manner.

Answer 1

When you make modification to a module you need to compile it.

If you do it in an erlang shell using the command c(module) or c(module,[options]), the new compiled version of the module is automatically loaded in that shell. It will be used by all the new process you launch.

For the one that are alive and already use it is is more complex to explain and I think it is not what you are asking for.

If you have several erlang shells running, only the one where you compile the module loaded it. That means that in the other shell, if the module were previously loaded, basically if you already use the module in those shell, and even if the corresponding processes are terminated, the new version is ignored.

Same thing if you use the command erlc to compile.

In all these cases, you need to explicitly load the module with the command l(module) in the shell.

Answer 2

Your server loop contain only local function calls. Running code is changed only if there is remote (or external) function call. So you have to export your loop function first:

-export([loop/3]).

and then you have to change all loop/3 calls in function receiveLoop/3 to

?MODULE:loop(...)

Alternatively you can do same thing with receiveLoop/3 instead. Best practice for serious applications is doing hot code swapping by demand so you change loop/3 to remote/external only after receiving some special message.