I have been playing with Jan's CouchDBX a bit and thought someone might enjoy what I did. CouchDBX is a nice little Mac OS X tool to run CouchDB without the need to set up Erlang or anything.

There are 3 major changes that I did. First of the UI is gone and everything is now in a status bar menu. Should make for quicker access to it and also stay out of the way. There is also a new transparent log window if you need to see what is happening on the Erlang level. The third an most important change is that CouchDBX now stores it's database in ~/Documents/CouchDB. Before the database was inside the Application bundle itself and all the data disappeared every time you downloaded a new release of CouchDBX.

I have not renamed it or anything in case Jan would like to incorporate these changes to the original code or something.

EDIT 26. Nov: There was a serious error in my old version that made the javascript engine not run correctly. This has now been fixed and you need to redownload.

• Download
• My Source

I have myself an iPod Touch. And even though you have allowed me to buy it you have deemed me not worthy of using it. You have decided that I should not be allowed to run 3rd party applications on it since my country (Iceland) is not worthy of the holy iTunes store. You have also deemed me not worthy of upgrading it for the same reason. I am not even worthy of developing applications for it since I don't live in the list of countries approved for iPod/iPhone development. And I just must ask you why?

I also have the Apple TV which you allowed me to buy. And again I was allowed to buy it just not use it. I'm not allowed to rent or buy movies. Why? I'm allowed to buy music and movies from Amazon or any other store and have it shipped to me. Suddenly when it's in digital form it's like it's a crime for me to shop it? What gives. And as many Apple TV owners I have installed Boxee to it so I can enjoy some extra features. But you have decided that is not allowed and in your latest update you removed it??!?!? This seems to be on purpouse this time and not some accidental breakage because of things you needed to update. It seems to me like you decided to remove it. And what gives you the right to enter my computer and remove things. I know for a fact that AppleTV is just a Mac Mini with Tiger and an app runnin full screen. I sometimes see glimpses of the window border and the close/minimize/zoom buttons. This is in no way different than if you would use your software update to remove competitor software like Microsoft Office on my iMac. How is this ok? And why would you do that to begin with? It's not like Boxee is in competition with you. I still use Apple TV's built in media player.

I know that the reason for why I'm not allowed to use the iTunes store is because of requirements from the record companies. But let me remind you that it is illegal for you to shut me out of it. It is actually 100% illegal for you to deny me shopping on the Danish iTunes store. I'm not kidding you check with your legal team. Europe is one big economic area and according to European laws I am allowed to shop in any European country and I should pay the same price + shipping and handling. So even though the record companies asked you it does not make it less of a crime. If laws have any meaning to you open up my access to the store. You know that sooner or later someone will force you to do that and force you to pay fines while doing that. So why not just do it now?

So please Apple. Stop hating me.

Regards. A Loyal Customer.

-module(knockknock).
-compile(export_all).

start_joke() ->
    register(person_1, erlang:spawn(knockknock, person1, [])),
    register(person_2, erlang:spawn(knockknock, person2, [])),
    person_1 ! start_joke.

relay(Person, Message) ->
    io:format("------- ~p -------~n", [Message]),
    Person ! Message.

person1() ->
    receive 
        start_joke ->
            relay(person_2, "Knock, Knock");
        "Who's There?" ->
            timer:sleep(100000),
            relay(person_2, "Java")
    end,
    person1().

person2() ->
    receive
        "Knock, Knock" ->
            relay(person_1, "Who's There?");
        "Java" ->
            relay(person_1, "Ha Ha")
    end,
    person2().

Enter the ERL_LIBS environment variable. Set that to a directory and all the subdirectories of it that include code will the added automatically to the code path. To add it open up the file /etc/bashrc and add the following:

ERL_LIBS=/Library/Erlang/lib
if [ -d $HOME/Library/Erlang/lib ]; then
  ERL_LIBS=$HOME/Library/Erlang/lib:$ERL_LIBS
fi
export ERL_LIBS

This way all libraries under /Library/Erlang/lib and /Users/JoeUser/Library/Erlang/lib will be added to Erlangs code paths. The libraries will be in priority before the system libraries but after the -pa code paths. Now you can add things like Mochiweb, Eunit, Nitrogen and more under the /Library/Erlang/lib directory.

You could also put this in the file /usr/local/bin/erl

Sproutcore

Lets start by creating the Sproutcore application. I will not go into detail into the Sproutcore code as JavaScript and Sprutcore are way beyond a single tutorial.

sc-init mochi_contacts
cd mochi_contacts

Inside mochi_contacts we find a nice little framework for our application. Lets start by creating our model with the command. "sc-gen model mochi_contacts/contacts". Then we edit our model at clients/mochi_contacts/model/contacts.js and add the following code.

resourceURL: 'contacts',
properties: ["guid","fullname",'email','mobile'],

commitChanges: function(){
    if(this.get('fullname') == '') this.set('fullname', 'Unnamed');
    this.commit();
}

This is pretty straight forward. resourceURL defines the location of the data source. In this case it would be http://localhost/contacts/. In properties we define the keys we want to read from that resource. The commitChanges function then makes sure we have the fullname property defined and commits the changes to the resource.

Next up is our master controller. The master contoller handles our list view at the side. Create it with the command "sc-gen controller mochi_contacts/master SC.CollectionController", open up the file clients/mochi_contacts/controller/masterController.js and add the following.

allowsEmptySelection: false,
allowsMultipleSelection: false,
canEditCollection: true,

addContact: function(sender){
    var content = this.get('content');
    var contact = MochiContacts.Contacts.newRecord({
        fullname: "Unnamed"
    },MochiContacts.server);

    contact.commitChanges();
    this.set('selection',[contact]);
},

delContact: function(sender){
    if(!confirm('Are you sure?')) return;
    var sel = (this.get('selection') || []).clone() ;
    var idx = sel.get('length') ;
    while(--idx >= 0) {
        var contact = sel.objectAt(idx);
        contact.destroy();
    }
},

Not much to see here. Just basic functions for creating and deleting contacts from the list and 3 properties for defining the behaviour of the list view.

So now we need a second controller that will handle the form itself. Create it with the command "sc-gen controller mochi_contacts/detail SC.ObjectController" and put the following inside clients/mochi_contacts/controller/detailController.js

contentBinding: 'MochiContacts.masterController.selection',
commitChangesImmediately: false

Wow. Even less we do here. We simply bind the content of the controller to the currently selected object of the master controller. We then define that we dont want the changes to be posted automatically because we will add a button to do that.

Now we have to define the view. Open up clients/mochi_contacts/english.lproj/body.rhtml and remove everything. Replace with the following:

<% content_for('body') do %>

<% split_view :workspace, :class => 'sc-app-workspace footer', 
    :direction => :horizontal do %>  
  <% view :sidebar, :outlet => true do %>
    <% scroll_view :master_list, :outlet => true do %>
      <%= list_view :list_view, 
            :outlet => true, 
            :content_value_key => 'fullname', 
            :content_value_editable => false,
            :can_reorder_content => true,
            :bind => { 
              :content => 'MochiContacts.masterController.arrangedObjects', 
              :selection => 'MochiContacts.masterController.selection' 
            }
            %>
    <% end %>
  <% end %>

  <%= split_divider_view :outlet => true, :width => 5 %>

  <% view :detail_view, :outlet => true do %>
    <table class="card-detail">

      <tr>
        <td><label>Full Name:</label></td>
        <td>
          <%= text_field_view :outlet => true, :hint => "Full Name",
            :bind => {
              :value => 'MochiContacts.detailController.fullname'
            } %>
        </td>
      </tr>

      <tr>
        <td><label>Email:</label></td>
        <td>
          <%= text_field_view :outlet => true, :hint => "email@email.com",
            :bind => {
              :value => 'MochiContacts.detailController.email'
            } %>
        </td>
      </tr>

      <tr>
        <td><label>Mobile:</label></td>
        <td>
          <%= text_field_view :outlet => true, :hint => "555-0000",
            :bind => {
              :value => 'MochiContacts.detailController.mobile'
            } %>
        </td>
      </tr>

      <tr>
        <td colspan="2" class="buttons">
          <%= button_view :outlet => true, 
            :title => "Cancel",
            :action => 'MochiContacts.detailController.discardChanges',
            :bind => {
              :enabled => 'MochiContacts.detailController.hasChanges'
            } %>
          <%= button_view :outlet => true, 
            :title => "Save Changes", :default => true,
            :action => 'MochiContacts.detailController.commitChanges',
            :bind => {
              :enabled => "MochiContacts.detailController.hasChanges"
            } %>
        </td>
      </tr>
    </table>

  <% end %>
<% end %>

<% view :footer, :class => 'sc-footer sc-square-theme' do %>
  <div class="left">
    <%= button_view :outlet => true, :label => '+', 
        :action => 'MochiContacts.masterController.addContact' %>
    <%= button_view :outlet => true, :label => '-', 
        :action => 'MochiContacts.masterController.delContact' %>
  </div>

<% end %> <!-- footer -->

<% end %>

In here we have defined the views and bound their properties to the controllers.

Next we connect the contollers to the model. We do that inside clients/mochi_contacts/main.js by replacing the line MochiContacts.server.preload(MochiContacts.FIXTURES); with the following commands:

var contactList = MochiContacts.Contacts.collection();
contactList.refresh();
MochiContacts.masterController.set('content', contactList);
MochiContacts.server.listFor(contactList);

Before we move to the Erlang part we have to edit sc-config. As javascript request are bound to it's own domain we have to proxy the request by adding this as the very last line:

proxy '/contacts', :to => 'localhost:8808', :cookie_domain => 'localhost'

Now you should be able to start the server with the command sc-server and take a look at the result in http://localhost:4020/mochi_contacts.

The Format

The format SproutCore uses for REST calls are:

• CREATE = [POST]http://somesite/resource/create
• READ = [GET]http://somesite/resource/list
• UPDATE = [POST]http://somesite/resource/updateGUIDNUMBER
• DELETE = [POST]http://somesite/resource/DESTROYGUIDNUMBER

The Post values for CREATE and UPDATE methods are like:

"records[0][mobile]" = "555-1234"
"records[0][email]" = "sam.jones@example.com"
"records[0][fullname]" = "Sam Joness"
"records[0][id]" =  "@658"

The body expected to return for the READ method is in JSON format and looks like:

{"records": [
    { 
    "guid": "@570",
    "type": "Contacts",
    "fullname": "Frank Smith",
    "email": "frank.smith@example.com",
    "mobile": "555-4433"
    },{
    "guid": "@658",
    "type": "Contacts",
    "fullname": "Sam Jones",
    "email": "sam.jones@example.com",
    "mobile": "555-1234"
    }],
"ids": ["@570", "@658"]
}

Each record needs to have guid and type must be the name of the model it belongs to. ids must be a list of all the guid keys.

For mochijson2:encode/1 to be able to create this from an erlang term the format of the erlang term would be:

{struct,[{<<"records">>,
          [{struct,[{<<"guid">>,<<"@570">>},
                    {<<"type">>,<<"Contacts">>},
                    {<<"fullname">>,<<"Frank Smith">>},
                    {<<"email">>,<<"frank.smith@example.com">>},
                    {<<"mobile">>,<<"555-4433">>}]},
           {struct,[{<<"guid">>,<<"@658">>},
                    {<<"type">>,<<"Contacts">>},
                    {<<"fullname">>,<<"Sam Jones">>},
                    {<<"email">>,<<"sam.jones@example.com">>},
                    {<<"mobile">>,<<"555-1234">>}]}]},
         {<<"ids">>,[<<"@570">>,<<"@658">>]}]}

The Mochiweb Server

Knowing the expected formats it should be easy to write a mochiweb server to handle this. This is my version. Possibly one of my worst Erlang code but after spending way to much time figuring out mochijson2 I'm just putting this out there. (How about some documentation mochiguys? ;)

-module(web_server).
-include_lib("stdlib/include/qlc.hrl").
-export([start/0,stop/0,dispatch_requests/1]).
-record (contacts, {guid, type, fullname, email, mobile}).

start() ->
    mnesia:create_schema([node()]),
    mnesia:start(),
    try
        mnesia:table_info(contacts, type)
    catch
        exit: _ ->
            mnesia:create_table(contacts, 
                [{attributes, record_info(fields, contacts)},
                {type, set},
                {disc_copies, [node()]}])
    end,
    mochiweb_http:start([{port, 8808},{loop, fun dispatch_requests/1}]).

stop() ->
    mochiweb_http:stop().

dispatch_requests(Req) ->
    Path = Req:get(path),
    Method = Req:get(method),
    Post = Req:parse_post(),
    io:format("~p request for ~p with post: ~p~n", [Method, Path, Post]),
    Response = handle(Method, Path, Post),
    Req:respond(Response).


handle('GET', "/contacts/list", _Post) ->
    F = fun() ->
        Q = qlc:q([ build_struct(C) || C <- mnesia:table(contacts) ]),
        Q2 = qlc:q(
            [ list_to_binary(C#contacts.guid) || C <- mnesia:table(contacts) ]),
        Records = qlc:e(Q),
        IDs = qlc:e(Q2),
        Struct = {struct, [{<<"records">>, Records},{<<"ids">>, IDs}]},
        JSON = mochijson2:encode(Struct),
        list_to_binary(JSON)
    end,
    {atomic, Result} = mnesia:transaction(F),
    {200, [{"Content-Type", "text/javascript"}], Result };

handle('POST', "/contacts/create", Post) ->
    Guid = proplists:get_value("records[0][_guid]", Post),
    FullName = proplists:get_value("records[0][fullname]", Post),
    Email = proplists:get_value("records[0][email]", Post),
    Mobile = proplists:get_value("records[0][mobile]", Post),
    F = fun() ->
          mnesia:write(#contacts{
            guid=Guid, type="Contacts", fullname=FullName, 
            email=Email, mobile=Mobile}) 
    end,
    mnesia:transaction(F),
    {200, [{"Content-Type", "text/plain"}], <<"Created">> };

handle('POST', "/contacts/update"++Guid, Post) ->
    FullName = proplists:get_value("records[0][fullname]", Post),
    Email = proplists:get_value("records[0][email]", Post),
    Mobile = proplists:get_value("records[0][mobile]", Post),
    F = fun() ->
          mnesia:write(#contacts{
            guid=Guid, type="Contacts", fullname=FullName, 
            email=Email, mobile=Mobile}) 
    end,
    mnesia:transaction(F),
    {200, [{"Content-Type", "text/plain"}], <<"Updated">> };

handle('POST', "/contacts/destroy"++Guid, _Post) ->
    F = fun() ->
          mnesia:delete({contacts, Guid}) 
    end,
    mnesia:transaction(F),
    {200, [{"Content-Type", "text/plain"}], <<"Destoyed">> };

handle(_, _, _) ->
    {404, [{"Content-Type", "text/plain"}], <<"Unknown Request">>}.

build_struct(Record) ->
    {struct, [
        {<<"guid">>, list_to_binary(Record#contacts.guid)},
        {<<"type">>, list_to_binary(Record#contacts.type)},
        {<<"fullname">>, list_to_binary(Record#contacts.fullname)},
        {<<"email">>, list_to_binary(Record#contacts.email)},
        {<<"mobile">>, list_to_binary(Record#contacts.mobile)}
    ]}.

Just compile this and start with web_server:start().

Download the source

ErlangX is basically an installation of the Erlang/OTP system. Basically it is installed in 2 locations. in /Library/Frameworks/Erlang.framework we have the standard Erlang installation with the standard libraries. In /Library/Erlang/lib there are a few other popular libraries preinstalled for you. In there would also go other libraries you would like to install system wide.

Erlang will also look into the directory /Users/USERNAME/Library/Erlang/lib/ for modules if it exists. These are for libraries you want only accessible to a single user.

Even though ErlangX is installed into /Library/Frameworks/Erlang.framework it is not yet set up as a real Cocoa framework. There are 2 reasons for this location. One is that other systems such as Ruby and Python are set up this way. The other is forward compatability. The intention is to create a real Cocoa framework out of this to help with the creation of Erlang ports or other Erlang related software in Objective-C. This is however not the first priority.

ErlangXCode is a plugin enabling the use of XCode as an IDE for Erlang development. It's all early work. Creating the XCode addons would not be possible without the amazing effort of Damien Bobillot who painstakingly found out how the XCode API works and shared it with us. If you install ErlangXCode without the ErlangX runtime install you have to make sure that erlc is available in /usr/local/bin. To see the basics of what I have currently you can check out this screencast(sorry about the watermark).

Now. As I have spent pretty much only 3-4 hours on this and most of it went into finding out how the XCode plugin system works there is a lot of things that need fixing. Syntax highliting is in early stages and a lot is missing. You can help by downloading the source and commiting to me changes or just editing the files installed in /Developer/Library/Xcode/Plug-ins/Erlang.xcplugin and sending me the changes. All help is much appreciated.

You can download the first test here. Although it should work fine be warned that this is an early test and some things may not work as advertised.

Well before you start any real software development in Erlang you really should start by reading the Programming Rules and Conventions on Ericsson's website. This should be your bible. Go ahead and read it now. Don't worry I'll wait.....

Back? Good. Now we can start this tutorial.

Housekeeping

We start by creating a directory for our application. In that directory we create the subdirectories doc, ebin and src. Now we create a file in the project root called Emakefile to ease the compilation of the software. Open up Emakefile and add the following:

{'src/sysinfo_server.erl', [{outdir, "ebin"}]}.

This basically lists our modules for compilation and tells Erlang to put the finished product into the ebin subdirectory.

Iteration 1: A Basic Server

Now lets take a look at the src/sysinfo_server.erl file. First declare the exports and add the start functions.

-module(sysinfo_server).
-export ([start/0, start/1, accept_connection/1, responder_loop/1]).

start() ->
    start(8023).

start(Port) ->
    {ok, ListeningSocket} = gen_tcp:listen(Port, 
       [list, {packet, 0}, {active, false}, {reuseaddr, true}]),
    accept_connection(ListeningSocket).

In start/1 we open up the socket using gen_tcp:listen/2 with the first parameter the port we want to use followed by the tcp options. I will not go in to details for the options but you can read about them in the gen_tcp module. We then pass the created socket to the the accept_connection/1 loop that handles accepting incoming connections.

accept_connection(ListeningSocket) ->
    {ok, Socket} = gen_tcp:accept(ListeningSocket),
    spawn_link(?MODULE, responder_loop, [Socket]),
    accept_connection(ListeningSocket).

Here we take the socket and wait for a connection to it with the command gen_tcp:accept/1. Thing to remember about gen_tcp:accept/1 command is that it waits forever for a connection and does not execute the next line until that connection is created. When we get the connection we use spawn_link/3 to create a seperate process running the responder_loop/1 loop that will handle all the communication to that client. The function then calls itself and waits for the next connection. Always keep this part simple. This way if something fails it will fail in responder_loop/1 thus only failing the single socket but our loop that accepts new connections is unlikely to fail and other socket continue to communicate. Lets now get to the responder loop.

responder_loop(Socket) ->
    case gen_tcp:recv(Socket, 0) of
        {ok, "exit\r\n"} ->
            gen_tcp:send(Socket, "Exiting \r\n"),
            gen_tcp:close(Socket);
        {ok, Other} ->
            gen_tcp:send(Socket, Other),
            responder_loop(Socket);
        {error, closed} ->
            ok
    end.

Here we take the data from gen_tcp:recv. The data includes the return character so we need to include that. If it matches "exit\r\n" we close the socket after sending a message back. Otherwise we echo the data back with gen_tcp:send/2 and recurse. Lets try it out by building the code and running it. Enter the following into the terminal at the project root.

bash$ erl -make
bash$ erl -pa ebin -run sysinfo_server start

Now using a telnet client telnet to localhost at port 8023. You should be able to get echoed back all that you type and type exit to break the connection. Close the server by typing in q(). in the erlang shell.

Iteration 2: Improving the server

First thing we are going to do is add a function that helps us to get the environment variable. As it is not a part of the data communication and might be a reusable function we decide to put it into it's another module called sysinfo_tools.erl. Start by adding it to the Emakefile by adding an identical line to what defines sysinfo_server.

{'src/sysinfo_tools.erl', [{outdir, "ebin"}]}.

Now create src/sysinfo_tools.erl and add the following.

-module (sysinfo_tools).
-export ([get_env/1]).

get_env(Var) ->
[CleanVar|_Rest] = string:tokens(Var, "\r\n\t "),
case os:getenv(CleanVar) of
  false -> "No Such Env";
  Result -> Result
end.

This is pretty simple. We take the input Var and remove all unwanted characters from it. We then call the os:getenv/1 function to retreive the environment variable. If it does not exist we return the value "No Such Env" or just simply return the value. no magic here so now we can get to the interesting part.

Now lets turn back to src/sysinfo_server.erl

First step is adding a function to assist us with sending data to the client. We want to run it with a list of strings and at the end it prints out a nice prompt for the user. So add this function.

send_lines(Socket,[]) ->
    gen_tcp:send(Socket, "\r\nEnvGet> ");
send_lines(Socket,[First|Rest]) ->
    gen_tcp:send(Socket,First),
    gen_tcp:send(Socket,"\r\n"),
    send_lines(Socket,Rest).

send_lines/2 takes a socket and a list as parameters. It prints out the first element and loops back with the rest. Finally when the list is empty it prints out a prompt and exits. Lets put it in use by changing accept_connection/1 so it looks like this.

accept_connection(ListeningSocket) ->
    {ok, Socket} = gen_tcp:accept(ListeningSocket),
    send_lines(Socket, ["Welcome to the EnvGet Service", 
        "Available commands are: list, get <env> and exit"]),
    spawn_link(?MODULE, responder_loop, [Socket]),
    accept_connection(ListeningSocket).

Now we want to add the list and get commands along with changing the code to use send_lines/2 so that the respoder loop looks like this.

responder_loop(Socket) ->
    case gen_tcp:recv(Socket, 0) of
        {ok, "get "++Var} ->
            Result = sysinfo_tools:get_env(Var),
            send_lines(Socket, [Result]),
            ?MODULE:responder_loop(Socket);
        {ok, "list\r\n"} ->
            Result = os:getenv(),
            send_lines(Socket, Result),
            ?MODULE:responder_loop(Socket);
        {ok, "exit\r\n"} ->
            send_lines(Socket, ["Exiting"]),
            gen_tcp:close(Socket);
        {ok, _Other} ->
            send_lines(Socket, ["Unknown Command"]),
            ?MODULE:responder_loop(Socket);
        {error, closed} ->
            ok
    end.

Well. First we take a look at the get command. Here we try to match a string that starts with "get " and add the rest to the variable Var. We then call our handy sysinfo_tools:get_env/1 function that gets the data for us. Next we try to match the command "list". We call os:getenv/0 and pass it on to the user. Since os:getenv/0's output is a list of strings we don't put brackets around like usually.

Now. Let's compile and run.

bash$ erl -make
bash$ erl -pa ebin -run sysinfo_server start

Try it out by telneting to locahost:8023 and trying out the commands "list" and "get HOME". It should work like a charm.

Well. Done for now. We would propably want to add a lot more before production. Like code reloading so the server doesn't have to go down for upgrades but that is a job for a later tutorial.

download the code if you have any problems.

nc/1 and nc/2

Remember c().? The command you use to compile code from the Erlang shell. Well nc/1 compiles and loads the code in all connected nodes. The source doesn't even need to exist in the remote nodes. Just try it by creating a bunch of nodes and typing nc(modulename). in one of them.

l/1 and nl/1

l/1 simply runs code:purge/1 and code:load_file/1 to remove code for a module marked as old. nl/1 does the same except on all connected nodes. Note that code:purge/1 removes old code even if it is in use. Also consider code:soft_purge/1 that only removes old code if no processes use it.

i/0 and ni/0

Another friend for the c module. i/0 gives you a list of processes and some good info on them. A valuable tool. Like you propably guessed the ni/0 function does the same for all the connected nodes.

slave:start/2

When you need to quickly start a bunch of slave nodes you should use slave:start/2. I'm not sure on the difference on those nodes and the regular but it still is a valueable tool when testing things.

toolbar:start/0

There are loads of valuable GUI tools for debugging in Erlang. toolbar:start/0 gives you a quick access to many of them such as the Mnesia Table Visualizer, Process Manager, The Debugger and the Application Monitor. The Table Visualizer by itself is something I use daily. You can also make your own tools into the toolbar. On a related note also check out webtool:start/0 and open up http://127.0.0.1:8888/ and check out how to make your own webtool.

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.

cd /tmp
curl http://ftp.ruby-lang.org/pub/ruby/1.9/ruby-1.9.0-3.tar.gz | tar zx
cd ruby-1.9.0-r18217

autoconf
./configure --prefix=/opt/ruby19
make
sudo make install

Now lets set up a command that puts you in the 1.9 sandbox when needed. Open up the file .profile in your home directory or create it if it does not exist. Add the following line

alias ruby19="export PATH=/opt/ruby19/bin:$PATH"

Close the Terminal window and open up again. Now everytime you need to put a terminal window into the Ruby 1.9 mode just type in the command ruby19. Try it out with the command ruby -v and you should see the reply:

ruby 1.9.0 (2008-07-25 revision 18217) [i686-darwin9.4.0]

Now just have fun in the sandbox. Remember that there now is a seperate gem repository so you need to get the gems you need with the gem command. For info on changes in Ruby 1.9 take a look at the Ruby 1.9: What To Expect or Migrating to Ruby 1.9 slideshows.