Speeding up the Erlang Edit, Compile, Run/Debug cycle

Question

What is the fastest way to edit an Erlang application, compile the code and see the running result? Preferably jumping in the Erlang shell on the last step.

My current newbie setup:

• A script that compiles the app and starts up the erl shell.
• Then I type in application:start(foo).
• When I fix a typo I recompile the module with c('module') and restart the app.

Is there a faster way? BTW. my editor of choice is Emacs.

Answer 1

what you can also try is erlbuild. Erlbuild is an simple application which looks in src directory for changed source files and if it finds some files, than it compiles and load the modules again. After loading the modules, erlbuild runs the the tests of the modules.

You can find the project under : https://github.com/ulfa/erlbuild

~Ulf

Answer 2

Here's my setup:

• While developing, I keep the Erlang shell open in a separate terminal window.
• I start compilation from the editor (using an key combination), or just by typing make in the source directory.
• After compilation, I load all changed modules at once by typing l() in Erlang shell. You can find this and some other useful macros here: http://www.snookles.com/erlang/user_default.erl

There's rarely a need to restart the whole Erlang application. Reloading changed modules is a more common use-case and it is usually enough to apply your changes.

Regarding application start: if your application depends on other applications, application:start() will fail, until you start all the dependencies. Because of that, it is common to write a helper function <your-app-name>:start(). Here's an example. Another useful function is <your-app-name>:stop().

With all these techniques applied, a workflow would look like this:

• Start the Erlang shell and keep it open; type<your-app-name>:start().
• Make changes; run compilation; type l() in your Erlang shell.
• When changes require application restart, type <your-app-name>:stop(), <your-app-name>:start().

Answer 3

You might look at rebar as a building tool. make:all/0 and the whole make module could help as well. To explicitly reload a module from the shell you can use l(Module). Finally, you might also be interested in creating an Erlang release to "wrap" all your Erlang applications.