librelist archives

« back to archive

(des)usos de ?MODULE

(des)usos de ?MODULE

From:
Marcelo Gornstein
Date:
2012-05-04 @ 18:05
Hola a todos, una vez mas con una consulta newbie!

En uno de los capítulos de "learn you some erlang"
(http://learnyousomeerlang.com/relups) veo que para poder llevar a
cabo un cambio de un modulo "en caliente", se utiliza en ciertas
partes una llamada "fully qualified" a ciertas funciones, por ejemplo
?MODULE:loop().

Aparentemente esto hace que al momento de continuar la ejecucion del
modulo (pausado previamente), la proxima llamada a esa funcion utilice
el codigo nuevo. Al menos esto es lo que interpreto, por favor
corrijanme en caso de que me haya ido a la banquina :)

La pregunta entonces es... hasta que punto usar o no usar "?MODULE"?.
Por ejemplo los extremos: "no usarlo nunca" y "usarlo siempre". Al
usarlo siempre, lo que observo es que la legibilidad del codigo
disminuye, y ademas me veo obligado a hacer un export de todas las
funciones de ese modulo. Y si no lo uso nunca, aparentemente mi codigo
pierde la posibilidad de ser actualizado en caliente.

Entonces.. en que momentos conviene o no usar estas llamadas fully
qualified? Hay 0 casos, 1 caso, o algunos casos donde es aceptado? o
es algun tipo de "buena práctica" hacerlo en cuales casos?

Espero se haya entendido :) Saludos!

-- 
--
skype: marcelog.gornstein
http://marcelog.github.com/
https://github.com/marcelog/
--
// I don't sleep. I coffee.
"Make everything as simple as possible, but not simpler." -- Albert Einstein
"There’s a lot of work happening behind the scenes, courtesy of the
Spring AOP framework"
"Why do I have this nagging hunch that you have no idea what you're doing?"
"Any society that would give up a little liberty to gain a little
security will deserve neither and lose both" - Benjamin Franklin
"Delivering stupid software faster just get's you more stupid
software" - Jeff Patton
"Utilitas, Venustas, Firmitas"
"Stop breaking tests. Stop it. Just, stop."
"Sending messages that nobody will read is as useful as writing emo
poetry" - learnyousomeerlang.com
"The class object inherits from Chuck Norris."
"Chuck Norris can divide by zero and can unit test an entire
application with a single assert."

Re: [erlar] (des)usos de ?MODULE

From:
Ariel Gómez
Date:
2012-05-04 @ 20:01
En mi opinión , no deberías "nunca" exportar funciones "privadas". 
Por otro lado si cargas un modulo, la próxima ejecución se realizara con  
la ultima versión en memoria. Los procesos que están corriendo no van a 
cambiar de versión hasta terminar , en el caso de loop() nunca termina por
lo cual nunca va a dejar de ejecutar "su versión" del modulo, a menos de 
que internamente hagas la llamada fully cualified.
Esto en algunos casos no es recomendable los cambios en caliente, siempre 
depende del tipo de cambio que estés realizando.
Podrías estar haciendo un cambio de flujo que haga caer el proceso loop().
Espero que sea de utilidad.

Saludos.
Ariel
-----Mensaje original-----
De: erlar@librelist.com [mailto:erlar@librelist.com] En nombre de Marcelo 
Gornstein
Enviado el: viernes, 04 de mayo de 2012 15:06
Para: erlar@librelist.com
Asunto: [erlar] (des)usos de ?MODULE

Hola a todos, una vez mas con una consulta newbie!

En uno de los capítulos de "learn you some erlang"
(http://learnyousomeerlang.com/relups) veo que para poder llevar a cabo un
cambio de un modulo "en caliente", se utiliza en ciertas partes una 
llamada "fully qualified" a ciertas funciones, por ejemplo ?MODULE:loop().

Aparentemente esto hace que al momento de continuar la ejecucion del 
modulo (pausado previamente), la proxima llamada a esa funcion utilice el 
codigo nuevo. Al menos esto es lo que interpreto, por favor corrijanme en 
caso de que me haya ido a la banquina :)

La pregunta entonces es... hasta que punto usar o no usar "?MODULE"?.
Por ejemplo los extremos: "no usarlo nunca" y "usarlo siempre". Al usarlo 
siempre, lo que observo es que la legibilidad del codigo disminuye, y 
ademas me veo obligado a hacer un export de todas las funciones de ese 
modulo. Y si no lo uso nunca, aparentemente mi codigo pierde la 
posibilidad de ser actualizado en caliente.

Entonces.. en que momentos conviene o no usar estas llamadas fully 
qualified? Hay 0 casos, 1 caso, o algunos casos donde es aceptado? o es 
algun tipo de "buena práctica" hacerlo en cuales casos?

Espero se haya entendido :) Saludos!

--
--
skype: marcelog.gornstein
http://marcelog.github.com/
https://github.com/marcelog/
--
// I don't sleep. I coffee.
"Make everything as simple as possible, but not simpler." -- Albert 
Einstein "There’s a lot of work happening behind the scenes, courtesy of 
the Spring AOP framework"
"Why do I have this nagging hunch that you have no idea what you're doing?"
"Any society that would give up a little liberty to gain a little security
will deserve neither and lose both" - Benjamin Franklin "Delivering stupid
software faster just get's you more stupid software" - Jeff Patton 
"Utilitas, Venustas, Firmitas"
"Stop breaking tests. Stop it. Just, stop."
"Sending messages that nobody will read is as useful as writing emo 
poetry" - learnyousomeerlang.com "The class object inherits from Chuck 
Norris."
"Chuck Norris can divide by zero and can unit test an entire application 
with a single assert."

-----
No se encontraron virus en este mensaje.
Comprobado por AVG - www.avg.com
Versión: 2012.0.1913 / Base de datos de virus: 2425/4977 - Fecha de 
publicación: 05/04/12

Re: [erlar] (des)usos de ?MODULE

From:
Marcelo Gornstein
Date:
2012-05-07 @ 12:46
Hola Ariel,

Gracias por la respuesta. La conclusion sería entonces que para dejar
la puerta abierta a los cambios "en caliente" de los procesos que
corren infinitamente, habria que hacer la llamada fully qualified
dentro del loop, y no seria necesario hacerla en otras partes del
codigo, verdad?

Gracias de nuevo! Saludos,

2012/5/4 Ariel Gómez <ariel.gomez@inswitch.us>:
> En mi opinión , no deberías "nunca" exportar funciones "privadas".
> Por otro lado si cargas un modulo, la próxima ejecución se realizara con
 la ultima versión en memoria. Los procesos que están corriendo no van a 
cambiar de versión hasta terminar , en el caso de loop() nunca termina por
lo cual nunca va a dejar de ejecutar "su versión" del modulo, a menos de 
que internamente hagas la llamada fully cualified.
> Esto en algunos casos no es recomendable los cambios en caliente, 
siempre depende del tipo de cambio que estés realizando.
> Podrías estar haciendo un cambio de flujo que haga caer el proceso loop().
> Espero que sea de utilidad.
>
> Saludos.
> Ariel
> -----Mensaje original-----
> De: erlar@librelist.com [mailto:erlar@librelist.com] En nombre de 
Marcelo Gornstein
> Enviado el: viernes, 04 de mayo de 2012 15:06
> Para: erlar@librelist.com
> Asunto: [erlar] (des)usos de ?MODULE
>
> Hola a todos, una vez mas con una consulta newbie!
>
> En uno de los capítulos de "learn you some erlang"
> (http://learnyousomeerlang.com/relups) veo que para poder llevar a cabo 
un cambio de un modulo "en caliente", se utiliza en ciertas partes una 
llamada "fully qualified" a ciertas funciones, por ejemplo ?MODULE:loop().
>
> Aparentemente esto hace que al momento de continuar la ejecucion del 
modulo (pausado previamente), la proxima llamada a esa funcion utilice el 
codigo nuevo. Al menos esto es lo que interpreto, por favor corrijanme en 
caso de que me haya ido a la banquina :)
>
> La pregunta entonces es... hasta que punto usar o no usar "?MODULE"?.
> Por ejemplo los extremos: "no usarlo nunca" y "usarlo siempre". Al 
usarlo siempre, lo que observo es que la legibilidad del codigo disminuye,
y ademas me veo obligado a hacer un export de todas las funciones de ese 
modulo. Y si no lo uso nunca, aparentemente mi codigo pierde la 
posibilidad de ser actualizado en caliente.
>
> Entonces.. en que momentos conviene o no usar estas llamadas fully 
qualified? Hay 0 casos, 1 caso, o algunos casos donde es aceptado? o es 
algun tipo de "buena práctica" hacerlo en cuales casos?
>
> Espero se haya entendido :) Saludos!
>
> --
> --
> skype: marcelog.gornstein
> http://marcelog.github.com/
> https://github.com/marcelog/
> --
> // I don't sleep. I coffee.
> "Make everything as simple as possible, but not simpler." -- Albert 
Einstein "There’s a lot of work happening behind the scenes, courtesy of 
the Spring AOP framework"
> "Why do I have this nagging hunch that you have no idea what you're doing?"
> "Any society that would give up a little liberty to gain a little 
security will deserve neither and lose both" - Benjamin Franklin 
"Delivering stupid software faster just get's you more stupid software" - 
Jeff Patton "Utilitas, Venustas, Firmitas"
> "Stop breaking tests. Stop it. Just, stop."
> "Sending messages that nobody will read is as useful as writing emo 
poetry" - learnyousomeerlang.com "The class object inherits from Chuck 
Norris."
> "Chuck Norris can divide by zero and can unit test an entire application
with a single assert."
>
> -----
> No se encontraron virus en este mensaje.
> Comprobado por AVG - www.avg.com
> Versión: 2012.0.1913 / Base de datos de virus: 2425/4977 - Fecha de 
publicación: 05/04/12
>



-- 
--
skype: marcelo.gornstein
http://marcelog.github.com/
https://github.com/marcelog/
--
// I don't sleep. I coffee.
"Make everything as simple as possible, but not simpler." -- Albert Einstein
"There’s a lot of work happening behind the scenes, courtesy of the
Spring AOP framework"
"Why do I have this nagging hunch that you have no idea what you're doing?"
"Any society that would give up a little liberty to gain a little
security will deserve neither and lose both" - Benjamin Franklin
"Delivering stupid software faster just get's you more stupid
software" - Jeff Patton
"Utilitas, Venustas, Firmitas"
"Stop breaking tests. Stop it. Just, stop."
"Sending messages that nobody will read is as useful as writing emo
poetry" - learnyousomeerlang.com
"The class object inherits from Chuck Norris."
"Chuck Norris can divide by zero and can unit test an entire
application with a single assert."

Re: [erlar] (des)usos de ?MODULE

From:
Mariano Guerra
Date:
2012-05-07 @ 18:16
2012/5/7 Marcelo Gornstein <marcelog@gmail.com>:
> Hola Ariel,
>
> Gracias por la respuesta. La conclusion sería entonces que para dejar
> la puerta abierta a los cambios "en caliente" de los procesos que
> corren infinitamente, habria que hacer la llamada fully qualified
> dentro del loop, y no seria necesario hacerla en otras partes del
> codigo, verdad?

o solo hacerla si reciben un mensaje por ejemplo "reload" que llama a
si misma con el mismo estado pero con una llamada fully qualified.

Re: [erlar] (des)usos de ?MODULE

From:
Marcelo Gornstein
Date:
2012-05-07 @ 18:21
en el caso de un loop, que hasta ahora siempre las tuve como funciones
privadas, hay manera de hacer la llamada fully qualified pero no
exportarla? la pregunta apunta a un detalle, que es tratar de exportar
la menor cantidad de funciones posibles.

2012/5/7 Mariano Guerra <luismarianoguerra@gmail.com>:
> 2012/5/7 Marcelo Gornstein <marcelog@gmail.com>:
>> Hola Ariel,
>>
>> Gracias por la respuesta. La conclusion sería entonces que para dejar
>> la puerta abierta a los cambios "en caliente" de los procesos que
>> corren infinitamente, habria que hacer la llamada fully qualified
>> dentro del loop, y no seria necesario hacerla en otras partes del
>> codigo, verdad?
>
> o solo hacerla si reciben un mensaje por ejemplo "reload" que llama a
> si misma con el mismo estado pero con una llamada fully qualified.



-- 
--
skype: marcelo.gornstein
http://marcelog.github.com/
https://github.com/marcelog/
--
// I don't sleep. I coffee.
"Make everything as simple as possible, but not simpler." -- Albert Einstein
"There’s a lot of work happening behind the scenes, courtesy of the
Spring AOP framework"
"Why do I have this nagging hunch that you have no idea what you're doing?"
"Any society that would give up a little liberty to gain a little
security will deserve neither and lose both" - Benjamin Franklin
"Delivering stupid software faster just get's you more stupid
software" - Jeff Patton
"Utilitas, Venustas, Firmitas"
"Stop breaking tests. Stop it. Just, stop."
"Sending messages that nobody will read is as useful as writing emo
poetry" - learnyousomeerlang.com
"The class object inherits from Chuck Norris."
"Chuck Norris can divide by zero and can unit test an entire
application with a single assert."

Re: [erlar] (des)usos de ?MODULE

From:
Mariano Guerra
Date:
2012-05-08 @ 15:08
On Mon, May 7, 2012 at 7:21 PM, Marcelo Gornstein <marcelog@gmail.com> wrote:
> en el caso de un loop, que hasta ahora siempre las tuve como funciones
> privadas, hay manera de hacer la llamada fully qualified pero no
> exportarla? la pregunta apunta a un detalle, que es tratar de exportar
> la menor cantidad de funciones posibles.

no sabria decirte, no tengo mucha experiencia con la parte OTP de
erlang (debo ser uno de los raros que no lo usa para eso :P)

alguien sabe la respuesta a eso?

Re: [erlar] (des)usos de ?MODULE

From:
Manuel A. Rubio \"Bombadil\"
Date:
2012-05-08 @ 16:57
Hola,

El 2012-05-08 17:08, Mariano Guerra escribió:
> On Mon, May 7, 2012 at 7:21 PM, Marcelo Gornstein 
> <marcelog@gmail.com> wrote:
>> en el caso de un loop, que hasta ahora siempre las tuve como 
>> funciones
>> privadas, hay manera de hacer la llamada fully qualified pero no
>> exportarla? la pregunta apunta a un detalle, que es tratar de 
>> exportar
>> la menor cantidad de funciones posibles.
>
> no sabria decirte, no tengo mucha experiencia con la parte OTP de
> erlang (debo ser uno de los raros que no lo usa para eso :P)
>
> alguien sabe la respuesta a eso?

creo que esto se realiza a través del "code_change", me explico con 
código:

-export([..., code_change/0]).

code_change() ->
     loop().

loop() ->
     ...
     ?MODULE:code_change().

En OTP, el "code_change" se usa, porque entre versiones, es posible que 
el State cambie, y esta función puede hacer la migración antes de volver 
al bucle principal, el loop, de nuevo. Puedes usar esta función como un 
"puente". En este caso, se ve claro que no realiza ninguna acción, nada 
más que no dar visibilidad al loop.

Un saludo.

-- 
Manuel A. Rubio "Bombadil"
Usuario de GNU/Linux #323628 acorde a http://counter.li.org/
Técnico en Admin. Sistemas Informáticos

Re: [erlar] (des)usos de ?MODULE

From:
Marcelo Gornstein
Date:
2012-05-08 @ 19:36
ah bien..

es equivalente a algo como:

code_change(State) ->
    NewState = [],
    {ok, NewState}.

loop(State) ->
    ...
    update ->
        {ok, NewState} = ?MODULE:code_change(State),
        loop(NewState).

podria haber un update/0 que envie el mensaje "update" al loop. al
momento de llamar a code_change/1 (dentro del loop), se llamaria a la
nueva version del modulo, y al retornar de code_change/1, la llamada a
loop/1 ya es tambien la de la nueva version?

2012/5/8 Manuel A. Rubio "Bombadil" <bombadil@bosqueviejo.net>:
> Hola,
>
> El 2012-05-08 17:08, Mariano Guerra escribió:
>> On Mon, May 7, 2012 at 7:21 PM, Marcelo Gornstein
>> <marcelog@gmail.com> wrote:
>>> en el caso de un loop, que hasta ahora siempre las tuve como
>>> funciones
>>> privadas, hay manera de hacer la llamada fully qualified pero no
>>> exportarla? la pregunta apunta a un detalle, que es tratar de
>>> exportar
>>> la menor cantidad de funciones posibles.
>>
>> no sabria decirte, no tengo mucha experiencia con la parte OTP de
>> erlang (debo ser uno de los raros que no lo usa para eso :P)
>>
>> alguien sabe la respuesta a eso?
>
> creo que esto se realiza a través del "code_change", me explico con
> código:
>
> -export([..., code_change/0]).
>
> code_change() ->
>     loop().
>
> loop() ->
>     ...
>     ?MODULE:code_change().
>
> En OTP, el "code_change" se usa, porque entre versiones, es posible que
> el State cambie, y esta función puede hacer la migración antes de volver
> al bucle principal, el loop, de nuevo. Puedes usar esta función como un
> "puente". En este caso, se ve claro que no realiza ninguna acción, nada
> más que no dar visibilidad al loop.
>
> Un saludo.
>
> --
> Manuel A. Rubio "Bombadil"
> Usuario de GNU/Linux #323628 acorde a http://counter.li.org/
> Técnico en Admin. Sistemas Informáticos



-- 
--
http://marcelog.github.com/
https://github.com/marcelog/
skype: marcelo.gornstein
twitter: @mgornstein
--
// I don't sleep. I coffee.
"Make everything as simple as possible, but not simpler." -- Albert Einstein
"There’s a lot of work happening behind the scenes, courtesy of the
Spring AOP framework"
"Why do I have this nagging hunch that you have no idea what you're doing?"
"Any society that would give up a little liberty to gain a little
security will deserve neither and lose both" - Benjamin Franklin
"Delivering stupid software faster just get's you more stupid
software" - Jeff Patton
"Utilitas, Venustas, Firmitas"
"Stop breaking tests. Stop it. Just, stop."
"Sending messages that nobody will read is as useful as writing emo
poetry" - learnyousomeerlang.com
"The class object inherits from Chuck Norris."
"Chuck Norris can divide by zero and can unit test an entire
application with a single assert."

Re: [erlar] (des)usos de ?MODULE

From:
Manuel A. Rubio \"Bombadil\"
Date:
2012-05-08 @ 21:00
Hola,

hice pruebas y sí, funciona así, cuando se llama a code_change de forma 
full qualified, se llama al nuevo código, y como este nuevo código llama 
a su función interna de loop, pues cambia todo el código correctamente.

Un saludo.

El 2012-05-08 21:36, Marcelo Gornstein escribió:
> ah bien..
>
> es equivalente a algo como:
>
> code_change(State) ->
>     NewState = [],
>     {ok, NewState}.
>
> loop(State) ->
>     ...
>     update ->
>         {ok, NewState} = ?MODULE:code_change(State),
>         loop(NewState).
>
> podria haber un update/0 que envie el mensaje "update" al loop. al
> momento de llamar a code_change/1 (dentro del loop), se llamaria a la
> nueva version del modulo, y al retornar de code_change/1, la llamada 
> a
> loop/1 ya es tambien la de la nueva version?
>
> 2012/5/8 Manuel A. Rubio "Bombadil" <bombadil@bosqueviejo.net>:
>> Hola,
>>
>> El 2012-05-08 17:08, Mariano Guerra escribió:
>>> On Mon, May 7, 2012 at 7:21 PM, Marcelo Gornstein
>>> <marcelog@gmail.com> wrote:
>>>> en el caso de un loop, que hasta ahora siempre las tuve como
>>>> funciones
>>>> privadas, hay manera de hacer la llamada fully qualified pero no
>>>> exportarla? la pregunta apunta a un detalle, que es tratar de
>>>> exportar
>>>> la menor cantidad de funciones posibles.
>>>
>>> no sabria decirte, no tengo mucha experiencia con la parte OTP de
>>> erlang (debo ser uno de los raros que no lo usa para eso :P)
>>>
>>> alguien sabe la respuesta a eso?
>>
>> creo que esto se realiza a través del "code_change", me explico con
>> código:
>>
>> -export([..., code_change/0]).
>>
>> code_change() ->
>>     loop().
>>
>> loop() ->
>>     ...
>>     ?MODULE:code_change().
>>
>> En OTP, el "code_change" se usa, porque entre versiones, es posible 
>> que
>> el State cambie, y esta función puede hacer la migración antes de 
>> volver
>> al bucle principal, el loop, de nuevo. Puedes usar esta función como 
>> un
>> "puente". En este caso, se ve claro que no realiza ninguna acción, 
>> nada
>> más que no dar visibilidad al loop.
>>
>> Un saludo.
>>
>> --
>> Manuel A. Rubio "Bombadil"
>> Usuario de GNU/Linux #323628 acorde a http://counter.li.org/
>> Técnico en Admin. Sistemas Informáticos
>
>
>
> --
> --
> http://marcelog.github.com/
> https://github.com/marcelog/
> skype: marcelo.gornstein
> twitter: @mgornstein
> --
> // I don't sleep. I coffee.
> "Make everything as simple as possible, but not simpler." -- Albert 
> Einstein
> "There’s a lot of work happening behind the scenes, courtesy of the
> Spring AOP framework"
> "Why do I have this nagging hunch that you have no idea what you're 
> doing?"
> "Any society that would give up a little liberty to gain a little
> security will deserve neither and lose both" - Benjamin Franklin
> "Delivering stupid software faster just get's you more stupid
> software" - Jeff Patton
> "Utilitas, Venustas, Firmitas"
> "Stop breaking tests. Stop it. Just, stop."
> "Sending messages that nobody will read is as useful as writing emo
> poetry" - learnyousomeerlang.com
> "The class object inherits from Chuck Norris."
> "Chuck Norris can divide by zero and can unit test an entire
> application with a single assert."

-- 
Manuel A. Rubio "Bombadil"
Usuario de GNU/Linux #323628 acorde a http://counter.li.org/
Técnico en Admin. Sistemas Informáticos

Re: [erlar] (des)usos de ?MODULE

From:
Mariano Guerra
Date:
2012-05-08 @ 21:19
2012/5/8 Manuel A. Rubio "Bombadil" <bombadil@bosqueviejo.net>:
> Hola,
>
> hice pruebas y sí, funciona así, cuando se llama a code_change de forma
> full qualified, se llama al nuevo código, y como este nuevo código llama
> a su función interna de loop, pues cambia todo el código correctamente.
>
> Un saludo.

que lindo ejemplo para poner en el wiki o en otro lado, te animas?

Re: [erlar] (des)usos de ?MODULE

From:
Manuel A. Rubio \"Bombadil\"
Date:
2012-05-08 @ 23:11
Hola Mariano,

El 2012-05-08 23:19, Mariano Guerra escribió:
> que lindo ejemplo para poner en el wiki o en otro lado, te animas?

¿En qué parte se pondría? ¿Recetario?

Un saludo.

-- 
Manuel A. Rubio "Bombadil"
Usuario de GNU/Linux #323628 acorde a http://counter.li.org/
Técnico en Admin. Sistemas Informáticos

Re: [erlar] (des)usos de ?MODULE

From:
Mariano Guerra
Date:
2012-05-08 @ 23:15
2012/5/9 Manuel A. Rubio "Bombadil" <bombadil@bosqueviejo.net>:
> Hola Mariano,
>
> El 2012-05-08 23:19, Mariano Guerra escribió:
>> que lindo ejemplo para poner en el wiki o en otro lado, te animas?
>
> ¿En qué parte se pondría? ¿Recetario?

si, si necesitas una cuenta avisame por privado.

Re: [erlar] (des)usos de ?MODULE

From:
Marcelo Gornstein
Date:
2012-05-09 @ 01:25
muy agradecido por el esfuerzo :) se puede detallar en la wiki (si no
es mucha molestia) en que consistieron las pruebas o como llevarlas a
cabo? me presto a ayudar si es necesario! me interesa mucho este
aspecto de otp.

saludos,


2012/5/8 Mariano Guerra <luismarianoguerra@gmail.com>:
> 2012/5/9 Manuel A. Rubio "Bombadil" <bombadil@bosqueviejo.net>:
>> Hola Mariano,
>>
>> El 2012-05-08 23:19, Mariano Guerra escribió:
>>> que lindo ejemplo para poner en el wiki o en otro lado, te animas?
>>
>> ¿En qué parte se pondría? ¿Recetario?
>
> si, si necesitas una cuenta avisame por privado.



-- 
--
http://marcelog.github.com/
https://github.com/marcelog/
skype: marcelo.gornstein
twitter: @mgornstein
--
// I don't sleep. I coffee.
"Make everything as simple as possible, but not simpler." -- Albert Einstein
"There’s a lot of work happening behind the scenes, courtesy of the
Spring AOP framework"
"Why do I have this nagging hunch that you have no idea what you're doing?"
"Any society that would give up a little liberty to gain a little
security will deserve neither and lose both" - Benjamin Franklin
"Delivering stupid software faster just get's you more stupid
software" - Jeff Patton
"Utilitas, Venustas, Firmitas"
"Stop breaking tests. Stop it. Just, stop."
"Sending messages that nobody will read is as useful as writing emo
poetry" - learnyousomeerlang.com
"The class object inherits from Chuck Norris."
"Chuck Norris can divide by zero and can unit test an entire
application with a single assert."

Re: [erlar] (des)usos de ?MODULE

From:
Manuel A. Rubio \"Bombadil\"
Date:
2012-05-09 @ 08:05
Hola Marcelo,

en principio, para que no tengas que esperar mucho, te detallo. El 
código que usé fue este:

--------------------------------------------------------
-module(prueba).
-export([code_change/0]).

code_change() ->
     loop().

loop() ->
     receive Any -> io:format("original: ~p~n", [Any]) end,
     prueba:code_change().
--------------------------------------------------------

La ejecución en la consola:

--------------------------------------------------------
Erlang R15B01 (erts-5.9.1) [source] [64-bit] [smp:4:4] 
[async-threads:0] [kernel-poll:false]

Eshell V5.9.1  (abort with ^G)
1> c(prueba).
{ok,prueba}
2> Pid = spawn(prueba, code_change, []).
<0.39.0>
3> Pid ! "hola", ok.
original: "hola"
ok
--------------------------------------------------------

En otra consola, cambiamos el código, solo la línea del mensaje por 
esta:

--------------------------------------------------------
loop() ->
     receive Any -> io:format("cambio: ~p~n", [Any]) end,
     prueba:code_change().
--------------------------------------------------------

De nuevo en consola:

--------------------------------------------------------
4> c(prueba).
{ok,prueba}
5> Pid ! "hola", ok.
original: "hola"
ok
6> Pid ! "hola", ok.
cambio: "hola"
ok
--------------------------------------------------------

En la primera llamada después de la compilación se está aún ejecutando 
el código antiguo, pero al pasar por el code_change, cambia el código. 
La compilación puede realizarse aparte, y cambiar el código así, por 
ejemplo:

--------------------------------------------------------
-module(prueba).
-export([code_change/0]).

code_change() ->
     loop().

loop() ->
     receive
         update ->
             code:purge(?MODULE),
             code:load_file(?MODULE),
             ?MODULE:code_change();
         Any ->
             io:format("original: ~p~n", [Any]),
             loop()
     end.
--------------------------------------------------------

Volvemos a ejecutar:

--------------------------------------------------------
Erlang R15B01 (erts-5.9.1) [source] [64-bit] [smp:4:4] 
[async-threads:0] [kernel-poll:false]

Eshell V5.9.1  (abort with ^G)
1> c(prueba).
{ok,prueba}
2> Pid = spawn(prueba, code_change, []).
<0.39.0>
3> Pid ! "hola", ok.
original: "hola"
ok
--------------------------------------------------------

Cambiamos el código de loop, otra vez solo el mensaje:

--------------------------------------------------------
loop() ->
     receive
         update ->
             code:purge(?MODULE),
             code:load_file(?MODULE),
             ?MODULE:code_change();
         Any ->
             io:format("cambio: ~p~n", [Any]),
             loop()
     end.
--------------------------------------------------------

Y esta vez lo compilamos en otra consola con "erlc". Volviendo a 
Erlang:

--------------------------------------------------------
4> Pid ! update.
update
5> Pid ! "hola", ok.
cambio: "hola"
ok
--------------------------------------------------------

Creo que ha quedado algo extenso... pero lo más importante, ¿quedó 
clara la explicación?

Un saludo.

-- 
Manuel A. Rubio "Bombadil"
Usuario de GNU/Linux #323628 acorde a http://counter.li.org/
Técnico en Admin. Sistemas Informáticos

Re: [erlar] (des)usos de ?MODULE

From:
Manuel A. Rubio \"Bombadil\"
Date:
2012-05-09 @ 08:57
Escrita la receta ;-)

http://erlang.org.ar/CambioDeCodigo

El 2012-05-09 10:05, Manuel A. Rubio "Bombadil" escribió:
> Hola Marcelo,
>
> en principio, para que no tengas que esperar mucho, te detallo. El
> código que usé fue este:
>
> --------------------------------------------------------
> -module(prueba).
> -export([code_change/0]).
>
> code_change() ->
>      loop().
>
> loop() ->
>      receive Any -> io:format("original: ~p~n", [Any]) end,
>      prueba:code_change().
> --------------------------------------------------------
>
> La ejecución en la consola:
>
> --------------------------------------------------------
> Erlang R15B01 (erts-5.9.1) [source] [64-bit] [smp:4:4]
> [async-threads:0] [kernel-poll:false]
>
> Eshell V5.9.1  (abort with ^G)
> 1> c(prueba).
> {ok,prueba}
> 2> Pid = spawn(prueba, code_change, []).
> <0.39.0>
> 3> Pid ! "hola", ok.
> original: "hola"
> ok
> --------------------------------------------------------
>
> En otra consola, cambiamos el código, solo la línea del mensaje por
> esta:
>
> --------------------------------------------------------
> loop() ->
>      receive Any -> io:format("cambio: ~p~n", [Any]) end,
>      prueba:code_change().
> --------------------------------------------------------
>
> De nuevo en consola:
>
> --------------------------------------------------------
> 4> c(prueba).
> {ok,prueba}
> 5> Pid ! "hola", ok.
> original: "hola"
> ok
> 6> Pid ! "hola", ok.
> cambio: "hola"
> ok
> --------------------------------------------------------
>
> En la primera llamada después de la compilación se está aún 
> ejecutando
> el código antiguo, pero al pasar por el code_change, cambia el 
> código.
> La compilación puede realizarse aparte, y cambiar el código así, por
> ejemplo:
>
> --------------------------------------------------------
> -module(prueba).
> -export([code_change/0]).
>
> code_change() ->
>      loop().
>
> loop() ->
>      receive
>          update ->
>              code:purge(?MODULE),
>              code:load_file(?MODULE),
>              ?MODULE:code_change();
>          Any ->
>              io:format("original: ~p~n", [Any]),
>              loop()
>      end.
> --------------------------------------------------------
>
> Volvemos a ejecutar:
>
> --------------------------------------------------------
> Erlang R15B01 (erts-5.9.1) [source] [64-bit] [smp:4:4]
> [async-threads:0] [kernel-poll:false]
>
> Eshell V5.9.1  (abort with ^G)
> 1> c(prueba).
> {ok,prueba}
> 2> Pid = spawn(prueba, code_change, []).
> <0.39.0>
> 3> Pid ! "hola", ok.
> original: "hola"
> ok
> --------------------------------------------------------
>
> Cambiamos el código de loop, otra vez solo el mensaje:
>
> --------------------------------------------------------
> loop() ->
>      receive
>          update ->
>              code:purge(?MODULE),
>              code:load_file(?MODULE),
>              ?MODULE:code_change();
>          Any ->
>              io:format("cambio: ~p~n", [Any]),
>              loop()
>      end.
> --------------------------------------------------------
>
> Y esta vez lo compilamos en otra consola con "erlc". Volviendo a
> Erlang:
>
> --------------------------------------------------------
> 4> Pid ! update.
> update
> 5> Pid ! "hola", ok.
> cambio: "hola"
> ok
> --------------------------------------------------------
>
> Creo que ha quedado algo extenso... pero lo más importante, ¿quedó
> clara la explicación?
>
> Un saludo.

-- 
Manuel A. Rubio "Bombadil"
Usuario de GNU/Linux #323628 acorde a http://counter.li.org/
Técnico en Admin. Sistemas Informáticos

Re: [erlar] (des)usos de ?MODULE

From:
Marcelo Gornstein
Date:
2012-05-09 @ 10:23
impecable, manuel, quedo super respondido :) muchas gracias por el
tiempo y el laburo :)

2012/5/9 Manuel A. Rubio "Bombadil" <bombadil@bosqueviejo.net>:
> Escrita la receta ;-)
>
> http://erlang.org.ar/CambioDeCodigo
>
> El 2012-05-09 10:05, Manuel A. Rubio "Bombadil" escribió:
>> Hola Marcelo,
>>
>> en principio, para que no tengas que esperar mucho, te detallo. El
>> código que usé fue este:
>>
>> --------------------------------------------------------
>> -module(prueba).
>> -export([code_change/0]).
>>
>> code_change() ->
>>      loop().
>>
>> loop() ->
>>      receive Any -> io:format("original: ~p~n", [Any]) end,
>>      prueba:code_change().
>> --------------------------------------------------------
>>
>> La ejecución en la consola:
>>
>> --------------------------------------------------------
>> Erlang R15B01 (erts-5.9.1) [source] [64-bit] [smp:4:4]
>> [async-threads:0] [kernel-poll:false]
>>
>> Eshell V5.9.1  (abort with ^G)
>> 1> c(prueba).
>> {ok,prueba}
>> 2> Pid = spawn(prueba, code_change, []).
>> <0.39.0>
>> 3> Pid ! "hola", ok.
>> original: "hola"
>> ok
>> --------------------------------------------------------
>>
>> En otra consola, cambiamos el código, solo la línea del mensaje por
>> esta:
>>
>> --------------------------------------------------------
>> loop() ->
>>      receive Any -> io:format("cambio: ~p~n", [Any]) end,
>>      prueba:code_change().
>> --------------------------------------------------------
>>
>> De nuevo en consola:
>>
>> --------------------------------------------------------
>> 4> c(prueba).
>> {ok,prueba}
>> 5> Pid ! "hola", ok.
>> original: "hola"
>> ok
>> 6> Pid ! "hola", ok.
>> cambio: "hola"
>> ok
>> --------------------------------------------------------
>>
>> En la primera llamada después de la compilación se está aún
>> ejecutando
>> el código antiguo, pero al pasar por el code_change, cambia el
>> código.
>> La compilación puede realizarse aparte, y cambiar el código así, por
>> ejemplo:
>>
>> --------------------------------------------------------
>> -module(prueba).
>> -export([code_change/0]).
>>
>> code_change() ->
>>      loop().
>>
>> loop() ->
>>      receive
>>          update ->
>>              code:purge(?MODULE),
>>              code:load_file(?MODULE),
>>              ?MODULE:code_change();
>>          Any ->
>>              io:format("original: ~p~n", [Any]),
>>              loop()
>>      end.
>> --------------------------------------------------------
>>
>> Volvemos a ejecutar:
>>
>> --------------------------------------------------------
>> Erlang R15B01 (erts-5.9.1) [source] [64-bit] [smp:4:4]
>> [async-threads:0] [kernel-poll:false]
>>
>> Eshell V5.9.1  (abort with ^G)
>> 1> c(prueba).
>> {ok,prueba}
>> 2> Pid = spawn(prueba, code_change, []).
>> <0.39.0>
>> 3> Pid ! "hola", ok.
>> original: "hola"
>> ok
>> --------------------------------------------------------
>>
>> Cambiamos el código de loop, otra vez solo el mensaje:
>>
>> --------------------------------------------------------
>> loop() ->
>>      receive
>>          update ->
>>              code:purge(?MODULE),
>>              code:load_file(?MODULE),
>>              ?MODULE:code_change();
>>          Any ->
>>              io:format("cambio: ~p~n", [Any]),
>>              loop()
>>      end.
>> --------------------------------------------------------
>>
>> Y esta vez lo compilamos en otra consola con "erlc". Volviendo a
>> Erlang:
>>
>> --------------------------------------------------------
>> 4> Pid ! update.
>> update
>> 5> Pid ! "hola", ok.
>> cambio: "hola"
>> ok
>> --------------------------------------------------------
>>
>> Creo que ha quedado algo extenso... pero lo más importante, ¿quedó
>> clara la explicación?
>>
>> Un saludo.
>
> --
> Manuel A. Rubio "Bombadil"
> Usuario de GNU/Linux #323628 acorde a http://counter.li.org/
> Técnico en Admin. Sistemas Informáticos



-- 
--
http://marcelog.github.com/
https://github.com/marcelog/
skype: marcelo.gornstein
twitter: @mgornstein
--
// I don't sleep. I coffee.
"Make everything as simple as possible, but not simpler." -- Albert Einstein
"There’s a lot of work happening behind the scenes, courtesy of the
Spring AOP framework"
"Why do I have this nagging hunch that you have no idea what you're doing?"
"Any society that would give up a little liberty to gain a little
security will deserve neither and lose both" - Benjamin Franklin
"Delivering stupid software faster just get's you more stupid
software" - Jeff Patton
"Utilitas, Venustas, Firmitas"
"Stop breaking tests. Stop it. Just, stop."
"Sending messages that nobody will read is as useful as writing emo
poetry" - learnyousomeerlang.com
"The class object inherits from Chuck Norris."
"Chuck Norris can divide by zero and can unit test an entire
application with a single assert."

Entradas del Blog (era: (des)usos de ?MODULE)

From:
Manuel A. Rubio \"Bombadil\"
Date:
2012-05-09 @ 11:51
Hola Marcelo,

El 2012-05-09 12:23, Marcelo Gornstein escribió:
> impecable, manuel, quedo super respondido :) muchas gracias por el
> tiempo y el laburo :)

de nada. Aprovecho para hacer "publi" :-P de los últimos artículos que 
escribí en el blog (relacionados con Erlang):

Erlang: Servidores UDP
http://bosqueviejo.net/2012/03/21/erlang-servidores-udp/

Erlang: Servidores Concurrentes TCP
http://bosqueviejo.net/2012/04/09/erlang-servidores-concurrentes-tcp/

No, Erlang no es eso
http://bosqueviejo.net/2012/04/18/no-erlang-no-es-eso/

Estructura Lider/Trabajador en Erlang
http://bosqueviejo.net/2012/05/07/estructura-lider-trabajador-en-erlang/

Perdón por el off-topic :-P

Un saludo.

-- 
Manuel A. Rubio "Bombadil"
Usuario de GNU/Linux #323628 acorde a http://counter.li.org/
Técnico en Admin. Sistemas Informáticos

Re: [erlar] Entradas del Blog (era: (des)usos de ?MODULE)

From:
Mariano Guerra
Date:
2012-05-09 @ 12:14
2012/5/9 Manuel A. Rubio "Bombadil" <bombadil@bosqueviejo.net>:
> Hola Marcelo,
>
> El 2012-05-09 12:23, Marcelo Gornstein escribió:
>> impecable, manuel, quedo super respondido :) muchas gracias por el
>> tiempo y el laburo :)
>
> de nada. Aprovecho para hacer "publi" :-P de los últimos artículos que
> escribí en el blog (relacionados con Erlang):
>
> Erlang: Servidores UDP
> http://bosqueviejo.net/2012/03/21/erlang-servidores-udp/
>
> Erlang: Servidores Concurrentes TCP
> http://bosqueviejo.net/2012/04/09/erlang-servidores-concurrentes-tcp/
>
> No, Erlang no es eso
> http://bosqueviejo.net/2012/04/18/no-erlang-no-es-eso/
>
> Estructura Lider/Trabajador en Erlang
> http://bosqueviejo.net/2012/05/07/estructura-lider-trabajador-en-erlang/
>
> Perdón por el off-topic :-P

no es offtopic, es mas, es muy ontopic :)

dado que no hay mucho escrito en espaniol sobre erlang estaria bueno
que lo vayamos organizando en algun lado para si alguien quiere
sentarse a leer sobre erlang en espaniol tenga donde empezar.

patada inicial: http://erlang.org.ar/ArticulosEnEspaniol

saludos!

Recursos (era: Entradas del Blog)

From:
Manuel A. Rubio \"Bombadil\"
Date:
2012-05-09 @ 12:27
Hola,

he aprovechado para meter más recursos, hay un libro de Erlang de la 
editorial Manning que es muy bueno, hace algún tiempo escribí sobre él:

http://bosqueviejo.net/2012/01/22/erlang-y-otp-en-accion/

He agregado en http://erlang.org.ar/AprendiendoErlang el enlace a la 
página oficial del libro y un recurso más:

http://aprendiendo-erlang.blogspot.com/

Es un blog muy bueno sobre Erlang.

Un saludo.

-- 
Manuel A. Rubio "Bombadil"
Usuario de GNU/Linux #323628 acorde a http://counter.li.org/
Técnico en Admin. Sistemas Informáticos

Re: [erlar] Recursos (era: Entradas del Blog)

From:
Marcelo Gornstein
Date:
2012-05-09 @ 12:37
excelente! voy a tener un fin de semana divertido parece jeje :D

todavia no vi los links, pero pregunto de antemano: conocen algun
*buen* articulo/libro/etc que hable con detalle y paso a paso como
armar una aplicacion "completa"? lease, dejar el codigo preparado para
los upgrades que veniamos hablando, y generar los appup y relups, etc?
espaniol o ingles

saludos!

2012/5/9 Manuel A. Rubio "Bombadil" <bombadil@bosqueviejo.net>:
> Hola,
>
> he aprovechado para meter más recursos, hay un libro de Erlang de la
> editorial Manning que es muy bueno, hace algún tiempo escribí sobre él:
>
> http://bosqueviejo.net/2012/01/22/erlang-y-otp-en-accion/
>
> He agregado en http://erlang.org.ar/AprendiendoErlang el enlace a la
> página oficial del libro y un recurso más:
>
> http://aprendiendo-erlang.blogspot.com/
>
> Es un blog muy bueno sobre Erlang.
>
> Un saludo.
>
> --
> Manuel A. Rubio "Bombadil"
> Usuario de GNU/Linux #323628 acorde a http://counter.li.org/
> Técnico en Admin. Sistemas Informáticos



-- 
--
http://marcelog.github.com/
https://github.com/marcelog/
skype: marcelo.gornstein
twitter: @mgornstein
--
// I don't sleep. I coffee.
"Make everything as simple as possible, but not simpler." -- Albert Einstein
"There’s a lot of work happening behind the scenes, courtesy of the
Spring AOP framework"
"Why do I have this nagging hunch that you have no idea what you're doing?"
"Any society that would give up a little liberty to gain a little
security will deserve neither and lose both" - Benjamin Franklin
"Delivering stupid software faster just get's you more stupid
software" - Jeff Patton
"Utilitas, Venustas, Firmitas"
"Stop breaking tests. Stop it. Just, stop."
"Sending messages that nobody will read is as useful as writing emo
poetry" - learnyousomeerlang.com
"The class object inherits from Chuck Norris."
"Chuck Norris can divide by zero and can unit test an entire
application with a single assert."

Re: [erlar] Recursos (era: Entradas del Blog)

From:
Manuel A. Rubio \"Bombadil\"
Date:
2012-05-09 @ 12:51
Hola,

yo comencé esto:
http://erldev.org

Pero está en un estado muy inicial, no tiene aún el soporte de pruebas 
(common_test y/o eunit)... y los appups me faltan aún también :-P , pero 
si usas rebar, esa herramienta te genera muy rápidamente un entorno 
donde trabajar, liberaciones, uso de dependencias, compilación de ports, 
etc. es muy completa:

https://github.com/basho/rebar

Un saludo.

-- 
Manuel A. Rubio "Bombadil"
Usuario de GNU/Linux #323628 acorde a http://counter.li.org/
Técnico en Admin. Sistemas Informáticos

Re: [erlar] Recursos (era: Entradas del Blog)

From:
Marcelo Gornstein
Date:
2012-05-09 @ 12:58
uso rebar.. pero aun no se como hacer esto puntualmente. puede ser
todo un topic aparte, de hecho :)

genero el release con "rebar generate", y puedo correr el nodo (y usar
los templates, etc). con eso me arreglo para desarrollar, pero hasta
ahi llegue jeje

me falta saber como se hace paso a paso el salto a produccion. por
ejemplo: hoy en dia genero un release para probar x cosa. si hago un
cambio, borro ese release (es decir, el directorio donde genero el
release), y lo vuelvo a generar con rebar (rebar clean, rebar compile,
rebar generate).

esto lo estoy haciendo de esta manera porque al querer ejecutar "rebar
generate" en formas consecutivas, obtengo errores de rebar que detecta
que hay files que ya existen).

2012/5/9 Manuel A. Rubio "Bombadil" <bombadil@bosqueviejo.net>:
> Hola,
>
> yo comencé esto:
> http://erldev.org
>
> Pero está en un estado muy inicial, no tiene aún el soporte de pruebas
> (common_test y/o eunit)... y los appups me faltan aún también :-P , pero
> si usas rebar, esa herramienta te genera muy rápidamente un entorno
> donde trabajar, liberaciones, uso de dependencias, compilación de ports,
> etc. es muy completa:
>
> https://github.com/basho/rebar
>
> Un saludo.
>
> --
> Manuel A. Rubio "Bombadil"
> Usuario de GNU/Linux #323628 acorde a http://counter.li.org/
> Técnico en Admin. Sistemas Informáticos



-- 
--
http://marcelog.github.com/
https://github.com/marcelog/
skype: marcelo.gornstein
twitter: @mgornstein
--
// I don't sleep. I coffee.
"Make everything as simple as possible, but not simpler." -- Albert Einstein
"There’s a lot of work happening behind the scenes, courtesy of the
Spring AOP framework"
"Why do I have this nagging hunch that you have no idea what you're doing?"
"Any society that would give up a little liberty to gain a little
security will deserve neither and lose both" - Benjamin Franklin
"Delivering stupid software faster just get's you more stupid
software" - Jeff Patton
"Utilitas, Venustas, Firmitas"
"Stop breaking tests. Stop it. Just, stop."
"Sending messages that nobody will read is as useful as writing emo
poetry" - learnyousomeerlang.com
"The class object inherits from Chuck Norris."
"Chuck Norris can divide by zero and can unit test an entire
application with a single assert."

Re: [erlar] (des)usos de ?MODULE

From:
Ariel Gomez
Date:
2012-05-07 @ 12:50
Si, así lo resuelvo yo en general.

El 7 de mayo de 2012 09:46, Marcelo Gornstein <marcelog@gmail.com> escribió:

> Hola Ariel,
>
> Gracias por la respuesta. La conclusion sería entonces que para dejar
> la puerta abierta a los cambios "en caliente" de los procesos que
> corren infinitamente, habria que hacer la llamada fully qualified
> dentro del loop, y no seria necesario hacerla en otras partes del
> codigo, verdad?
>
> Gracias de nuevo! Saludos,
>
> 2012/5/4 Ariel Gómez <ariel.gomez@inswitch.us>:
> > En mi opinión , no deberías "nunca" exportar funciones "privadas".
> > Por otro lado si cargas un modulo, la próxima ejecución se realizara con
>  la ultima versión en memoria. Los procesos que están corriendo no van a
> cambiar de versión hasta terminar , en el caso de loop() nunca termina por
> lo cual nunca va a dejar de ejecutar "su versión" del modulo, a menos de
> que internamente hagas la llamada fully cualified.
> > Esto en algunos casos no es recomendable los cambios en caliente,
> siempre depende del tipo de cambio que estés realizando.
> > Podrías estar haciendo un cambio de flujo que haga caer el proceso
> loop().
> > Espero que sea de utilidad.
> >
> > Saludos.
> > Ariel
> > -----Mensaje original-----
> > De: erlar@librelist.com [mailto:erlar@librelist.com] En nombre de
> Marcelo Gornstein
> > Enviado el: viernes, 04 de mayo de 2012 15:06
> > Para: erlar@librelist.com
> > Asunto: [erlar] (des)usos de ?MODULE
> >
> > Hola a todos, una vez mas con una consulta newbie!
> >
> > En uno de los capítulos de "learn you some erlang"
> > (http://learnyousomeerlang.com/relups) veo que para poder llevar a cabo
> un cambio de un modulo "en caliente", se utiliza en ciertas partes una
> llamada "fully qualified" a ciertas funciones, por ejemplo ?MODULE:loop().
> >
> > Aparentemente esto hace que al momento de continuar la ejecucion del
> modulo (pausado previamente), la proxima llamada a esa funcion utilice el
> codigo nuevo. Al menos esto es lo que interpreto, por favor corrijanme en
> caso de que me haya ido a la banquina :)
> >
> > La pregunta entonces es... hasta que punto usar o no usar "?MODULE"?.
> > Por ejemplo los extremos: "no usarlo nunca" y "usarlo siempre". Al
> usarlo siempre, lo que observo es que la legibilidad del codigo disminuye,
> y ademas me veo obligado a hacer un export de todas las funciones de ese
> modulo. Y si no lo uso nunca, aparentemente mi codigo pierde la posibilidad
> de ser actualizado en caliente.
> >
> > Entonces.. en que momentos conviene o no usar estas llamadas fully
> qualified? Hay 0 casos, 1 caso, o algunos casos donde es aceptado? o es
> algun tipo de "buena práctica" hacerlo en cuales casos?
> >
> > Espero se haya entendido :) Saludos!
> >
> > --
> > --
> > skype: marcelog.gornstein
> > http://marcelog.github.com/
> > https://github.com/marcelog/
> > --
> > // I don't sleep. I coffee.
> > "Make everything as simple as possible, but not simpler." -- Albert
> Einstein "There’s a lot of work happening behind the scenes, courtesy of
> the Spring AOP framework"
> > "Why do I have this nagging hunch that you have no idea what you're
> doing?"
> > "Any society that would give up a little liberty to gain a little
> security will deserve neither and lose both" - Benjamin Franklin
> "Delivering stupid software faster just get's you more stupid software" -
> Jeff Patton "Utilitas, Venustas, Firmitas"
> > "Stop breaking tests. Stop it. Just, stop."
> > "Sending messages that nobody will read is as useful as writing emo
> poetry" - learnyousomeerlang.com "The class object inherits from Chuck
> Norris."
> > "Chuck Norris can divide by zero and can unit test an entire application
> with a single assert."
> >
> > -----
> > No se encontraron virus en este mensaje.
> > Comprobado por AVG - www.avg.com
> > Versión: 2012.0.1913 / Base de datos de virus: 2425/4977 - Fecha de
> publicación: 05/04/12
> >
>
>
>
> --
> --
> skype: marcelo.gornstein
> http://marcelog.github.com/
> https://github.com/marcelog/
> --
> // I don't sleep. I coffee.
> "Make everything as simple as possible, but not simpler." -- Albert
> Einstein
> "There’s a lot of work happening behind the scenes, courtesy of the
> Spring AOP framework"
> "Why do I have this nagging hunch that you have no idea what you're doing?"
> "Any society that would give up a little liberty to gain a little
> security will deserve neither and lose both" - Benjamin Franklin
> "Delivering stupid software faster just get's you more stupid
> software" - Jeff Patton
> "Utilitas, Venustas, Firmitas"
> "Stop breaking tests. Stop it. Just, stop."
> "Sending messages that nobody will read is as useful as writing emo
> poetry" - learnyousomeerlang.com
> "The class object inherits from Chuck Norris."
> "Chuck Norris can divide by zero and can unit test an entire
> application with a single assert."
>