Showing posts with label Erlang. Show all posts
Showing posts with label Erlang. Show all posts

Monday, November 09, 2015

Volviéndonos funcionales con SAP HANA y Erlang

Este post fué posteado originalmente en Getting functional with SAP HANA and Erlang.


Erlang es un lenguaje y sistema de ejecución concurrente de propósito general con recolección de variables. Y también es funcional, con evaluación impaciente, asignamiento único y tipeado dinámico. Me olvidé de mencionar que también es distribuído, concurrente y toleránte a fallos?.


Una descripción bastante grande, no? Bueno…Erlang ha estado presente desde hace más o menos los últimos 30 años…


Así que…ninguna demostración estaría completa si la enlazaramos con SAP HANA, so? Así que…vamos a hacerlo -;)

Primero, debemos crear un objeto Join y asociar la tabla por MANDT y CARRID. De ahí, seleccionar los siguientes campos como output MANDT, CARRID, CARRNAME, PRICE y CURRENCY.

Luego crear un objeto Aggregation seleccionándo los campos CARRNAME, PRICE (Como columnas agregadas) y CURRENCY. Debemos filtrar el campo CURRENCY por ‘USD’.

Luego, debemos crear un objeto Projection y seleccionar solo PRICE y CARRNAME.

En el objeto Semantics asegúrense de marcar  “CROSS CLIENT” como cliente por defecto.


Ahora, cambiemos a la vista SAP HANA Development y creemos un nuevo repositorio. Lo llamaremos“Flights”.

Creamos un proyecto “XS Engine” y también lo llamamos “Flights”. Lo enlazamos con el repositorio “Flights”.

Creamos un archivo vacio llamado “.xsapp”.

Creamos un archivo llamado “.xsaccess” con el siguente código.

.xsaccess
{
          "exposed" : true,
          "authentication" : [ { "method" : "Basic" } ]
}

Finalmente creamos un archivo llamado “flights.xsodata” con el siguiente código

flights.xsodata
service {
          "Blag/FLIGHTS_BY_CARRIER.calculationview" as "FLIGHTS" keys 
                                                        generate local "Id";
}

Activamos el proyecto y lanzamos nuestro browser...deberíamos ver algo como esto…


La parte de SAP HANA está lista…así que ahora podemos pasar a la parte de Erlang…

Erlang, a diferencia de muchos otros lenguajes, no tiene un manejador de paquetes, así que solamente debemos descargar el paquete que necesitamos, compilarlo y utilizarlo -;)

Para programar en Erlang uso uno de los más impresionántes editores que he encontrado hasta ahora…Geany. Viene practimente pre configurado para manejar muchos lenguajes de programación, así que debería dejarte listo para utilizar Erlang.

Necesitamos descargar mochijson2.erl y guardarlo en la carpeta de nuestro proyecto, luego simplemente debemos compilarlo escribiendo

erlc mochijson2.erl

Del terminal o presionándo el botón. El primero de la imagen.


Con eso, deberíamos estar más que listos para comenzar a programar -:) Copien y peguen el siguiente código…

Erlang_HANA.erl
-module(erlang_HANA).
-export([getOData/0,showInfo/5]).

showInfo(Carriers, Prices, Acc, Len, Ctr) when Ctr =< Len ->
 showInfo(Carriers, Prices,  Acc ++ [binary_to_list(lists:nth(Ctr,Carriers))] ++ [": "] ++
   [binary_to_list(lists:nth(Ctr,Prices))] ++ ["\n"], Len, Ctr + 1);
showInfo(_, _, Acc, Len, Ctr) when Ctr > Len ->
 io:format("~s",[Acc]).
 
getOData() ->
 inets:start(),
 Response = httpc:request(get, {"http://54.65.196.224:8000/Flights/flights.xsodata/FLIGHTS?$format=json", 
                          [{"Authorization", "Basic " ++ base64:encode_to_string("SYSTEM:Blag1977")}]}, [], []),
 Flights = mochijson2:decode(response_body(Response)),
 {struct, JsonData} = Flights,
 {struct, D} = proplists:get_value(<<"d">>, JsonData),
 Results = proplists:get_value(<<"results">>, D),
 Carriers = [proplists:get_value(<<"CARRNAME">>, S) || {struct, S} <- Results],
 Prices = [proplists:get_value(<<"PRICE">>, S) || {struct, S} <- Results],
 showInfo(Carriers, Prices, "", length(Carriers), 1).

response_body({ok, { _, _, Body}}) -> Body.

Guarda tu archivo y presiona el botón “Run or view the current file”. El último de la foto, que parece dos engranajes.


Debemos utilizar el formato “nombre_del:archivo:método()”para cargarlo en memoria y ejecutarlo -;)

Saludos,

Blag.
Development Culture.

Friday, August 22, 2014

Programming Erlang Software for a Concurrent World - Review del Libro

Acabo de terminar de leer Programming Erlang Software for a Concurrent World por Joe Armstrong...el creador de Erlang.

Nada mejor que leer sobre un lenguaje, que de la boca de su mismo creador -:)


El libro es enorme con 519 páginas...pero vale la pena leer cada una de las páginas...llenas de ejemplos buenos, divertidos y bien explicados, el Sr. Armstrong hace que ames Erlang -:)

Aprende sobre Programación Secuencial, Programación Concurrente, Programación Distribuída, Sockets, DETS, OTP y Mnesia...entre otros...




Este libro es excelente y he aprendido muchísimo...por supuesto...aunque aún soy un novato en Erlang..tengo suficientes conocimientos como para construír pequeñas aplicaciones y divertirme un montón -;)

Lo que me gusta del libro es que es bastante ligero e informal...los ejemplos no son muy fáciles ni muy difíciles, así que utilizarlos para aprender es simplemente perfecto...

Erlang es un lenguaje que vale más que pena aprender...y este libro realmente hace su trabajo de engancharte y dejarte queriendo más...

Saludos,

Blag.
Development Culture.

Wednesday, August 06, 2014

Decimal a Romanos - Al estilo Erlang

Mientras continúo con mi aprendizaje de  Erlang...decidí tratar de hacer una aplicación de Números Decimales a Romanos...tal como lo he hecho con otros lenguajes de programación en el pasado...y no fué tan fácil como pensaba -:)

Primero...no existe algo como arrays asociativos en Erlang...también...solo puedes asignar variables una vez...encima de todo, no hay loops...pero...a quien le importa...la programación funcional es divertida -;)

Por supuesto...mi código podría haber sido hecho mejor...pero...estoy aprendiendo...y programando aprendo más...así que por mi está bien...

Esto es lo que escribí -;)

roman_numerals.erl
-module(roman_numerals).
-export([showRomans/1]).
-define(DECIMALS,{1000,900,500,400,100,90,50,40,10,9,5,4,1}).

showRomans(Number) when is_integer(Number) ->
 showRomans(Number,1,"").

showRomans(0,_,Acc) ->
 io:format("~s~n",[Acc]);
showRomans(Number,Counter,Acc) ->
 case Number >= element(Counter,?DECIMALS) of 
  true -> showRomans(Number - element(Counter,?DECIMALS),
         Counter,Acc ++ make_roman(element(Counter,?DECIMALS)));
  false -> showRomans(Number,Counter + 1,Acc)
 end.
  
make_roman(1) -> "I";make_roman(4) -> "IV";make_roman(5) -> "V";
make_roman(9) -> "IX";make_roman(10) -> "X";make_roman(40) -> "XL";
make_roman(50) -> "L";make_roman(90) -> "XC";make_roman(100) -> "C";
make_roman(400) -> "CD";make_roman(500) -> "D";make_roman(900) -> "CM";
make_roman(1000) -> "M".

Cuando lo ejecutamos...podemos ver que funciona bastante bien -;)


Como pueden ver...Erlang es todo acerca de funciones, recursividad, acumuladores y una nueva forma de pensar -:)

Saludos,

Blag.
Development Culture.

Friday, August 01, 2014

Learn You Some Erlang for great good! - Review del libro

Hoy día...recién hace un par de minutos...he terminado de leer Learn You Some Erlang for great good! y debo decirle...estoy tan alegre como cansado -:)


Este libro es grande...y no estoy bromeando...es "Dios mio, este libro es grande"...con 628 páginas...y muchos...muchos ejemplos...

Este libro es tan bueno que es considerando como parte de la documentación standard de Erlang..o algo por el estilo...o por lo menos...así es como yo pienso que debería ser considerado...

El libro empieza con los fundamentos básicos de Erlang (los mismos que hace que te duela el cerebro)...y luego sigue avanzando introduciendo temas como Concurrency, Multiprocessing, Supervisors, OTP, Event Handlers y más...mucho más...

Leer este libro te dará todas las herramientas y el conocimiento necesarios para empezar a construir aplicaciones...

Si nunca antes haz escuchado sobre Erlang y quires probarlo...este libro es totalmente para ti...pero...una frase de alerta...este libro está lleno de contenidos...que puede facilmente agotarte y hacer que tu cerebro te duela aún más...

Ahora que he terminado el libro...estoy seguro de que voy a regresar para re-leer algunos capítulos a medida que vaya necesitándolos...afortunadamente...con tantos ejemplos es fácil comprender todos los temas aunque sea de una manera superficial...



Por supuesto...todavía soy un novato...así que próximo libro (con review por supuesto) va a ser Programming Erlang (Software for a Concurrent World) escrito por Joe Amstrong (uno de los creadores de Erlang)...

Casi lo olvidaba...también pueden leer Learn You Some Erlang for great good! online...

Saludos,

Blag.
Development Culture.

Friday, July 25, 2014

Mi primer post sobre Erlang

Así que...hace un par de días atrás decidí (por segunda vez) aprender Erlang...pero esta vez...me lo estoy tomando en serio -;)

Pero...que diablos es Erlang? En palabras simples...en un lenguaje de programación multi-paradigma, concurrente y funcional...simple, no?

Erlang es realmente un excelente y buen lenguaje...pero...luego de estos par de días...mi cerebro me está comenzando a doler...ya le haré saber más adelánte porque...

En fín...estoy leyendo Learn You Some Erlang for Great Good...que puede ser leído online aquí o comprado aquí. Yo lo compré -;)

Así que...pueden esperar un interesante review apenas termine de leerlo...

Como hago usualmente con nuevos lenguajes de programación...quería portar algo que ya había hecho antes hacia Erlang...porque para mi...esa es la mejor manera de entender...

Tomé el código para una salida LED que había construído para Python y Julia y lo porte a Erlang...pueden leer el blog aquí.

Aquí está el código en Erlang...

led.erl
-module(led).
-export([showLED/0,showLED/1]).

printLines(Counter,Long,Lines,Digits,Line1,Line2,Line3)
 when Counter > Long ->
  [io:format("~s",[X]) || X <- Line1], io:format("~n"),
  [io:format("~s",[X]) || X <- Line2], io:format("~n"),
  [io:format("~s",[X]) || X <- Line3], io:format("~n");
  
printLines(Counter,Long,Lines,Digits,Line1,Line2,Line3)
 when Counter =< Long ->
 printLines(Counter+1,Long,Lines,Digits,
      Line1 ++ [element(1,element(1,X)) || {X,Y}<-Lines, Y == element(Counter,list_to_tuple(Digits))],
      Line2 ++ [element(1,element(2,X)) || {X,Y}<-Lines, Y == element(Counter,list_to_tuple(Digits))],
      Line3 ++ [element(1,element(3,X)) || {X,Y}<-Lines, Y == element(Counter,list_to_tuple(Digits))]).

showLED() ->
 io:format("You must enter a number!~n").
            
showLED(Number) ->
 Lines = [{{{" _  ",1},{"| | ",2},{"|_| ",3}},0},{{{"  ",1},{"| ",2},{"| ",3}},1},
   {{{" _  ",1},{" _| ",2},{"|_  ",3}},2},{{{"_  ",1},{"_| ",2},{"_| ",3}},3},
   {{{"    ",1},{"|_| ",2},{"  | ",3}},4},{{{" _  ",1},{"|_  ",2},{" _| ",3}},5},
   {{{" _  ",1},{"|_  ",2},{"|_| ",3}},6},{{{"_   ",1},{" |  ",2},{" |  ",3}},7},
   {{{" _  ",1},{"|_| ",2},{"|_| ",3}},8},{{{" _  ",1},{"|_| ",2},{" _| ",3}},9}],
 Line1 = "", Line2 = "", Line3 = "", Counter = 1,
 Numbers = integer_to_list(Number),
 Long = length(Numbers),
 Digits = lists:map(fun(X) -> X - 48 end, Numbers),
 printLines(Counter,Long,Lines,Digits,Line1,Line2,Line3).

Y aquí está el resultado...


Así que...voy a decirles porque me duele el cerebro...y espero que esto no los haga alejarse de Erlang...au contraire...en realidad debería de darle una oportunidad a Erlang -;)

Primero...Las variables son invariables...lo cual significa...una vez que asignamos que A = 1 entonces A va a ser 1 por siempre y para siempre...no importa cuantas veces hagas A = 2...A va a seguir siendo 1...y por supuesto vas a tener un error si intentas hacer A = 2...porque A es 1...entiendes!

Segundo...No hay loops...no hay For's...no hay While's...no hay Do...While's...nada...solo recursión...funciones que se llaman a ellas mismas...multiples veces hasta que algo las haga parar...

Tercero...String...no son strings...sip...no hay strings en Erlang...todo es numérico...así que al final "A" es 65...

Cuarto...Orientación a Objetos...ni siquiera lo intenten...no sirve...este es un lenguaje de programación funcional...olvidate de las clases, metodos, atributos, friends, templates...y todo eso...

Ok...porque querrías aprender Erlang luego de leer todas estas cosas sin sentido? Fácil...porque Erlang cambia tu forma de pensar completamente...olvidate de todo lo que haz aprendido antes...debes pensar y hacer las cosas de una manera totalmente distinta...pero creánme...luego de un par de días con Erlang...te vas a convertir en un mejor programador...eso se los aseguro...

Saludos,

Blag.
Development Culture.