In my specific case, in Spain, for people that has their own servers and serve their own content as this blog to users in spanish language (mainly) this IP adresses could be lock by default. This IP adress are from servers with contents in another languages as russian or chinesse. Therefore, I did make my small contribution to the comunity with this file, to avoid the attacks from this IP adress in other servers:

The list

If someone found in this list any IP that shouldn’t appears in, only add a comment to study its exclusion from the list.

The installation could be automated in GNU/Linux systems as script at system boot in the following way:

curl http://bosqueviejo.net/wp-content/uploads/blacklist | sh

Always run it as root user.

Thanks to Ferd aportation (author of Learn You Some Erlang), we have history in Erlang shell too. Throught the project erlang-history, with an easy installation we can use the history with the Erlang shell.

A fast way to do it:

git clone git://github.com/ferd/erlang-history.git
cd erlang-history
make install

You can see the configuration in the project’s official website: erlang-history.

It has a new syntax for projects, we have dropped the original simple/multi structure and now, has only one simple model. In this way, an application could be created and has in contrib dir another projects as dependencies. However, the configure execution in dependencies is a task to do.

Added start-dev.sh script, which let us run the code without install the application. This is a standard in a lot of other projects in Internet. However we can uso too the make run format to do this.

Added rebar use insted of Makefile. Although rebar is a tool very similar to erldev, erldev is oriented to use GNU buildtools, as many projects in serveral languages in Internet. Among, rebar dependencies is based in download from original repositories as github and, Erldev is as Debian repositories, is based in use its own repositories to mantains the versions and code to build your application without worry if these code is there or not.

All you need you can find it at: http://erldev.org

New packages added or upgraded: cowboy, proper, dispcount, gen_leader, lager, quoted y tls.

Any comment you could write a comment below or go to user forum at ErlDev site.

Las gemas de Ruby son paquetes de librerías para Ruby que se instalan en el sistema y quedan listas para ser usadas, con un simple require o con mecanismos que aporta el propio sistema de gemas para Ruby.

El gestor de gemas: rubygems

En distribuciones de GNU/Linux, e instalaciones automáticas para Windows, se nos habilita un comando, generalmente, que nos permite agregar librerías y código de un repositorio muy extenso de código listo para usar. Esto es conocido como el gestor de gemas, rubygems, o simplemente gem.

El gestor de gemas es un comando que nos permite listar las gemas instaladas, buscar gemas remotas o localmente (de las instaladas), instalar, actualizar y eliminar gemas. Se puede saber si está instalado simplemente ejecutando:

gem --version

Criticizing its style

Is curious that people as Damien Katz (founder of CouchDB), or Toni Arcieri (founder of Reia) has been the first persons criticizing the language they choose to write their software for.

In this sense, others as Yariv Sadan, have defended and recognized some comments and, before read both, I asked myself… have they really understand what Erlang is?, what it does and what are it’s powers?, how to make the most of it, as well as concurrency oriented programming?

Criticizing the sintaxis

First, all people criticize Erlang for is its syntax. I remember the first time i saw C language. I was programming in Basic, Pascal and Modula-2 and i said… how bizarre! and the same when i saw Perl some years later

The C-like syntax is very used in programming world, but is not understandable for a person that start from scratch to program. Niklaus Wirth develop some languages as Pascal, to teach to program in pseudocode way.

Erlang, however, follows a methodology such as Prolog, is oriented to the development of mathematical functions, so then function has a closure (->) for its begin and ends with a dot. Each element inside of mathematical function or expression is separated by commas, and all is functional, ergo, all element in Erlang do something and MUST returns something, even the condicional structures, therefore has the way it has.

Data types: records and strings

The records are, at preprocessor level: tuples. This is that, functions as record_info does not really exists, therefore do not use variables in this macro and the records has a limitation. However, there are some tricks to use to do it in this way.

Another problem, with data types, are strings. The strings are integer lists. This not should surprise, in all languages are byte lists (or arrays). In C language, by example:

char c[] = "This is a string";
char d[] = { 'T', 'h', 'i', 's', 32, 'i', 's', 32, ..., 0 };
 
printf("%s\n", strcmp(c, d)==0 ? "true" : "false");

This give us true, because both byte lists are equals. In Erlang can see something like this with integer lists:

[100,111,103] == "dog".

This returns true too.

Performance

Really, after reading the Toni post, when I read: Erlang sucks at managing memory; he talks about a Erlang and Azul Vega comparation. Azul Vega is a 54-core processor optimized to run a JVM special.

A software with these processor and these JVM, NOT run in a distributed fashion, really, only will be distributed tasks between internal cores. Therefore, the procesor is not designed to connect to another nodes, therefore NOT is scalable. Also, only has four channels to memory access. In a 27 nodes cluster of Pentium IV with HyperThreading, we can do this work using Erlang… and also we can scale to more nodes.

Is a general porpouse language?

Erlang was created for environments to develop concurrent software, this feature is ideal for all kind servers, and now, for modern desktops, where software should run in a concurrent way.

Can Erlang develop web applications?, Yes, ChicagoBoss, or Erlyweb, or Nitrogen are examples for this. Can Erlang develop desktop applications? Yes, Wings3D is a good example for this. Does Erlang use to do server applications? Sure! was created for this.

In my opinion, if PHP has this denomination and is a markup language, Erlang MUST has it

Unique assigment… why?

To trace better the code, sure, and because a functional language do not need too many variables. By example, as say Damien Katz en his post, has this code:

f(X) ->
  X1 = foo(X),
  X2 = bar(X1),
  baz(X2).

This code, well write:

f(X) ->
  baz(bar(foo(X))).

Do you like add logs to see the change between function calls? … then you can do with another functions:

log(Caller, X) -> io:format("~s: ~p~n", [Caller, X]), X.
f(X) ->
  log("BAZ: ", baz(log("BAR: ", bar(log("FOO: ", foo(X)))))).

Is not really complex wheter you write and sort the code in a correct way… in other languages, as in example C, we can write code as this:

char *s = "Count this string";
int size;
for (int i=0, size; s[i]!='\0' && i<100; i++, size++)
  ;

Another codes in Perl are more afraid… but it always depends of the programmer.

The development itself

I think that is not understable, is the development in Erlang, as is, is not scalable, nor redundant, nor leverage all cores and machine processors, so as the rest of connecting nodes. To take avantage of Erlang is develop software in a concurrent fashion, with the correct patterns.

By example, Erlang can run, only in a node, almost 2 millions of concurrent process. This is, each task to do should run in its own process, and this process launched in appropiate core, processor and/or node. As well as we develop software wich PVM or MPICH.

Use OTP patterns is essential to take the maximum avantage of Erlang architecture and to create event handlers, state machines, shared memories in several servers, etc. should do, necessary, throught the Erlang mechanisms.

If we use Erlang to do calls to Mnesia, from any part of code with the dirty calls and generating a new process for each isolated request, we have a software with concurrent potential errors and, that no take avantage of configurated and connected nodes in the system.

Ending

I feel unprofesional write this kind of posts, both Tony and Damien, where write a list of circunstances slightly contrasted and due to low knowledge of language and, precisely they, they has been developed great applications in this language.

Java, seamsly, is a great language, but as Tony comment in his post, require of RTSJ specification in the JVM, in the comparisons, by example, even talks about buy special hardware to develop something like Erlang does in every architecture, i think they are less objetives.

The finite state machines can be used to define elements to interacts with an application. Begins in a defined state and throught events, can change its state until its ending.

A finite state machine can be somthing simpler as an alarm clock (or cron system), or a bank transaction, or a phone call, …

In this post I develop an example to show you the simple to develop this problems using OTP.

The Finite State Machine Generator

In the Erlang OTP set of functions, has one specific that is named gen_fsm. This is the short name to generator: finite state machine. As his name say, is a generator. The generators, in Eralng/OTP are behaviours, base code used as framework to develop a specific behaviour.

A module in Erlang is as simpler as define the first line with the module name, specify the functions export and, after that define the functions. The smallest module that you can write could has three lines of code.

The generators are different, these need a specific line to indicate the behaviour to implement and the definition of all callbacks for the base code.

Itself, the gen_fsm is the base code that keeps running and, when an event arrive, this code generate a call to a specific function (a callback). By convention, the callbacks has a specific form, both in name and in params, and the returns is normalized as well.

To make things easier, we rely on this template, but suppressing comments to not take up much.

Elevator example

This examples is very simple. Supose that we have an elevator to three floors: ground, first and second. This elevator has only two buttons labeled as: up and down; stops in every floor each time. Therefore, depending on the floor that is, the buttons has valid functionality or not.

If we are inside of elevator, in the first floor, we can press up button or down button, the elevator will have an state to go… but if we are in the ground floor (B), by example, press the down button has no sense.

Developing the solution

The code, giving the gen_fsm template will be simple. We have three states and two events by state. We have six functions to develop:

-module(elevator).
-behaviour(gen_fsm).
 
-compile([export_all]). % to do: change by -export(...).
 
-record(state, {}).
 
start_link() ->
    gen_fsm:start_link({local, ?MODULE}, ?MODULE, [], []).
 
init([]) ->
    {ok, ground_floor, #state{}}.
 
ground_floor(down, State) ->
    io:format("Beeep!, invalid option~n", []),
    {next_state, ground_floor, State};
ground_floor(up, State) ->
    io:format("Up to first floor~n", []),
    {next_state, first_floor, State}.
 
first_floor(down, State) ->
    io:format("Down to ground floor~n", []),
    {next_state, ground_floor, State};
first_floor(up, State) ->
    io:format("Up to second floor~n", []),
    {next_state, second_floor, State}.
 
second_floor(down, State) ->
    io:format("Down to first floor~n", []),
    {next_state, first floor, State};
second_floor(up, State) ->
    io:format("Beeep!, invalid option~n", []),
    {next_state, second_floor, State}.
 
% add two functions to make calls easy
% they are optional:
 
up_button() ->
    gen_fsm:send_event(?MODULE, up).
 
down_button() ->
    gen_fsm:send_event(?MODULE, down).

If you see the figure, and the code convertion, you will see that there are a direct relation between the schema and the code. This make develop very easy a state system as: bank transaction, internet payment, bidding, a phone call, a contest, a videogame, etc.

How works

The function start_link, and which are defined below, they are not really of the system itself, but helpers to run the state machine and interact with it.

The state machine, at the begining run init function. This function give an state and let pass data to keep between calls or events to FSM.

Once are running, the base code call the appropiate function, named as current state name.

Running the code

Once the write the code, we can run the Erlang virtual machine and run without problems:

$ erl
[...]
1> c(elevator). % compile the code.
{ok,elevator}
2> elevator:start_link(). % launch the state machine.
{ok,<0.38.0>}
3> elevator:down_button().
Beeep!, invalid option
ok
4> elevator:up_button().
Up to first floor
ok

The state machine does the calls to the functions, according to the state it is and the event que was launch.

Adding time

A good thing about FSM, is that, not only has events by calls, but also by time, therefore, in the example, we can add that, the elevator does not keep in the same floor more than 5 seconds, going up and down each time, until press a button.

Here we need the memory to know, if we going from up, then goes to down, when arrive to first floor, and vice versa.

Adding memory is as simpler as modify the state record to indicate the address to go:

-record(state, {address}).
 
init([]) ->
    {ok, ground_floor, #state{address=up}, 5000}.

The time is measured in miliseconds, therefore this code does the elevator start and, if not press a button in 5 seconds, the elevator goes up alone. In this case we add a new event:

The new functions:

ground_floor(down, _State) ->
    io:format("Beeep!, incorrect option~n", []),
    {next_state, ground_floor, #state{address=up}, 5000};
ground_floor(up, _State) ->
    io:format("Up to first floor~n", []),
    {next_state, first_floor, #state{address=up}, 5000};
ground_floor(timeout, _State) ->
    io:format("Up automatic to first floor~n", []),
    {next_state, first_floor, #state{address=up}, 5000}.
 
first_floor(down, State) ->
    io:format("Down to ground floor~n", []),
    {next_state, ground_floor, State, 5000};
first_floor(up, State) ->
    io:format("Up to second floor~n", []),
    {next_state, second_floor, State, 5000};
first_floor(timeout, State) ->
    NextState = case State#state.address of
        up -> 
            io:format("Up automatic to second floor~n", []),
            second_floor;
        down ->
            io:format("Down automatic to ground floor~n", []),
            ground_floor
    end,
    {next_state, NextState, State, 5000}.
 
second_floor(down, State) ->
    io:format("Down to first floor~n", []),
    {next_state, first_floor, State, 5000};
second_floor(up, State) ->
    io:format("Beeep!, incorrect option~n", []),
    {next_state, second_floor, State, 5000};
second_floor(timeout, _State) ->
    io:format("Down automatic to first floor~n", []),
    {next_state, first_floor, #state{address=down}, 5000}.

With this, we have the three states, with the three events, ergo, the code for the nine possible functions that can be in runtime.

In case of have a lot of states, we could use the handle_event format, the state name will be the first param and could admin throught code. The events works so, therefore in this sense, can be unify or optimize.

Ending

The FSM systems for Erlang, give us a big power to do, in easy fashion, an element that, in case of will be asked or generating evetns from several concurrent places, its interface does its behaviour will be the appropiate in each moment.