Me Dev, You Jane

When it comes to building your Erlang application there is no shortage of possibilities.

Directory Setup

The bare setup of the simplest Erlang program are 2 directories. Namely src and ebin. For beginners these are the ones you will most likely use for your first few programs. There are a few others however. Lets go over the whole list.

• ./bin In here you will put shell applications to, for example, start your application.
• ./doc Your Generated Documents.
• ./ebin Compiled erlang source code for the vm.
• ./include Used for include files.
• ./priv Used for application specific files. For example, C executables are placed here.
• ./src Your source code goes here.

Make-ing

There are 3 main methods of building Erlang programs. Make, Emake and Rake. I generally dislike makefiles so I will focus on the later 2.

EMake

EMake is Erlangs own make utility. It's quite simple but not very powerful. To get started you can create a file called Emakefile in your project root and list your sourcefiles.

{'src/myerlang.erl', [{outdir, "ebin"}]}.
{'src/myerlang_app.erl', [{outdir, "ebin"}]}.
{'src/myerlang_supervisor.erl', [{outdir, "ebin"}]}.

Now you can build your Erlang program by typing in you terminal erl -make. Often we the also use a Makefile to trigger the erlang make. The reason is that sometimes we want to add more commands to do various management tasks. Take this Makefile for example.

all: compile

    compile:
        @erl -make

    clean:
        rm -f ebin/*.beam
        rm -f erl_crash.dump

    run:
        erl -sname console -pa ebin

Here we have 3 available commands in our Terminal. Entering make will compile our code and make clean will remove all the compiled code. make run will start an erlang shell.

Rake

The method I prefer is using Rakefiles. Rake is a powerful and simple alternative to Make created in Ruby. Here is my Rakefile based on Sean's example. This goes in your project root in a file called Rakefile.

require 'rake'
require 'rake/clean'

# Configuration
START_MODULE = "myerlang"
TEST_MODULE = "test_myerlang"
MNESIA_DIR = "/tmp"


# No Need to change
PWD = `pwd`.strip
INCLUDE = "include"
ERLC_FLAGS = "-I#{INCLUDE} +warn_unused_vars +warn_unused_import"

SRC = FileList['src/**/*.erl']
OBJ = SRC.pathmap("%{src,ebin}X.beam")
CLEAN.include(['**/*.dump'])
CLOBBER.include(['**/*.beam'])

directory 'ebin'


rule ".beam" =>  ["%{ebin,src}X.erl"] do |t|
  sh "erlc -pa ebin -W #{ERLC_FLAGS} -o ebin #{t.source}"
end

desc "Compile all"
task :compile => ['ebin'] + OBJ

desc "Open up a shell"
task :shell => [:compile] do
    sh("erl -sname #{START_MODULE} -pa #{PWD}/ebin")
end

desc "Open up a shell and run #{START_MODULE}:start()" 
task :run => [:compile] do
    sh("erl -sname #{START_MODULE} -pa #{PWD}/ebin -run #{START_MODULE} start")
end

desc "Run Unit Tests" 
task :test do
  sh("erl -noshell -s #{TEST_MODULE} test -s init stop")
end


desc "Generate Documentation"
task :doc do
    sh("cd doc && erl -noshell -run edoc files ../#{SRC.join(" ../")} -run init stop")
end


task :default => :compile

You can get a list of functions to run by typing in rake -T in the project root. As compile is the default you can just build your code by entering simply rake in you terminal.