viernes, 31 de diciembre de 2010

Feliz 2011!!!


Un año transcurrió juntos, les deseo que se cumplan todos sus anhelos. En el 2011 espero que me sigan acompañando.


Feliz 2011 a todos!!!

jueves, 30 de diciembre de 2010

WSO2 Business Process Server




Estuve probando WSO2 Business Process Server (BPS) y quede gratamente sorprendido. No tengo experiencia en soluciones BPEL pero por lo pronto este producto me gusto.

WSO2 Business Process Server (BPS) es un Open Source Business Process Server fácil de usar que ejecuta procesos de negocios escritos siguiendo WS-BPEL estándar.

WS-BPEL esta emergiendo como un estándar por defecto para componer múltiples servicios asíncronos o síncronos, dentro de un flujo de procesos colaborativo y transaccional que incrementa la flexibilidad y agilidad de nuestra SOA (Service Oriented Architecture).

WSO2 BPS esta formado por Apache ODE e incluye una interfaz administrativa basada en la Web y funcionalidades de simulación. Además disponible con licencia Apache v2.

La versión actual de BPS es la 1.1.1

Dejo Link:

http://wso2.com/products/business-process-server/

lunes, 27 de diciembre de 2010

La propiedad intelectual tiene más valor cuando se comparte

Me gusto este post así que decidido compartirlo:

Más de Erlang

Continuando con el post: http://emanuelpeg.blogspot.com/2010/12/erlang.html vamos a seguir aprendiendo algo de erlang.

El case:

1> Animal = "dog".
2> case Animal of
2> "dog" -> underdog;
2> "cat" -> thundercat
2> end.
underdog

3> case Animal of
3> "elephant" -> dumbo;
3> _ -> something_else
3> end.
something_else

el _ es como el “default” de c, c++, java, etc...

El si es un tanto diferente a lo que conocemos, el si puede tener varias condiciones y varios resultados:

8> X = 0.
9> if
9> X > 0 -> positive;
9> X < 0 -> negative;
9> true -> zero
9> end.

Similar a javascript se puede asignar una función a una variable:

16> Negate = fun(I) -> -I end.
#Fun

17> Negate(1).
-1
18> Negate(-1).
1

Podemos usar funciones con listas

1> Numbers = [1, 2, 3, 4].
[1,2,3,4]
2> lists:foreach(fun(Number) -> io:format("~p~n", [Number]) end, Numbers).
1
2
3
4
ok

lists:foreach permite aplicar una función a cada elemento de una lista.
Si queremos filtrar los menores a 3 por ejemplo, es muy facil con lists:filter :

11> Small = fun(X) -> X < 0 end.

12> lists:filter(Small, Numbers).
[1,2]

EL lenguaje también provee una forma de saber si todos los elementos de una lista cumplen con un filtro:

15> lists:all(Small, [0, 1, 2]).
true
16> lists:all(Small, [0, 1, 2, 3]).
false


o si alguno lo cumple:

17> lists:any(Small, [0, 1, 2, 3]).
true
18> lists:any(Small, [3, 4, 5]).
false

Con foldl se puede hacer que una variable sea mantenida mientras la función esta iterando por la lista:

28> Numbers.
[1,2,3,4]
29> lists:foldl(fun(X, Sum) -> X + Sum end, 0, Numbers).
10

Como podemos ver la variable Sum se va pasando por cada ejecución de la función que acumula, y al comenzar la ejecución Sum = 0.
Hasta aquí hemos recorrido a vuelo de pájaro Erlang, un lenguaje original que nos muestra que se pueden hacer las cosas de diferente modo.

lunes, 20 de diciembre de 2010

Frase

Me gusto mucho esta frase y la quiero compartir:

La complejidad es uno de los principales problemas de la tecnología informática. Y que una y otra vez caemos en el error de que para resolver la complejidad lo que hace falta es todavía más complejidad.
-Donald Ferguson

Totalmente de acuerdo!!

domingo, 19 de diciembre de 2010

Erlang


Ya hemos hablado de erlangs en otros post, vamos a hacer un repaso y luego desarrollar ejemplos.

Erlang es un lenguaje de programación concurrente y un sistema de ejecución que incluye una máquina virtual y bibliotecas.

El subconjunto de programación secuencial de Erlang es un lenguaje funcional, con evaluación estricta, asignación única, y tipado dinámico. Fue diseñado en la compañía Ericsson para realizar aplicaciones distribuidas, tolerantes a fallos, soft-real-time y de funcionamiento ininterrumpido. Proporciona el cambio en caliente de código de forma que éste se puede cambiar sin parar el sistema. Originalmente, Erlang era un lenguaje propietario de Ericsson, pero fue cedido como software de código abierto en 1998. La implementación de Ericsson es, principalmente interpretada pero también incluye un compilador HiPE (sólo soportado en algunas plataformas).

La creación y gestión de procesos es trivial en Erlang, mientras que, en muchos lenguajes, los hilos se consideran un apartado complicado y propenso a errores. En Erlang toda concurrencia es explícita.

Bueno vamos a bajarnos el runtime de http://www.erlang.org/download.html esto para windows, si estan en linux es más fácil instalarlo por ejemplo en debian es así “apt-get install erlang”, y listo!

Se puede escribir codigo en un archivo .erl y luego compilarlo opteniendo el .beam (ejecutable) nosotros vamos a usar la consola.

Escribimos en la consola erl o werl(para windows)

erl
Erlang (BEAM) emulator version 5.4.13 [source]
Eshell V5.4.13 (abort with ^G)
1>

1> % Este es un comentario
2> 2 + 2.
4
3> 2 + 2,0.
4,0

Veamos las listas:
4> [1, 2, 3,4]
[1, 2, 3,4]

No se puede hacer operaciones con diferentes tipos por ejemplo la suma:

5> 4 + "string".
** exception error: bad argument in an arithmetic expression
in operator +/2
called as 4 + "string"

Las variables deben comenzar con mayuscula:

7> Var = 1.
1
8> Var = 2.
=ERROR REPORT==== 8-Jan-2010::11:47:46 ===
Error in process <0.39.0> with exit value: {{badmatch,2},[{erl_eval,expr,3}]}
** exited: {{badmatch,2},[{erl_eval,expr,3}]} **
8> Var.
1
Como se puede ver solo se puede asignar un valor a una variable una vez; esto es asi porque Erlang es un lenguaje funcional.

Un símbolo es una palabra en minuscula (en la mayoria de los lenguajes que lo implementa) que sirve para representar algo. En Erlang el símbolo se denomina atoms.

9> red.
red
10> Pill = blue.
blue
11> Pill.
blue


Las listas son un conjunto de elementos que pueden tener diferente tipo y longitud:

13> [1, 2, 3].
[1,2,3]
14> [1, 2, "three"].
[1,2,"three"]
15> List = [1, 2, 3].
[1,2,3]

Tuples es una lista fija y heterogénea:

18> {one, two, three}.
{one,two,three}
19> Origin = {0, 0}.
{0,0}

Estas estructuras pueden convinarse:

20> {name, "Spaceman Spiff"}.
{name,"Spaceman Spiff"}
21> {comic_strip, {name, "Calvin and Hobbes"}, {character, "Spaceman Spiff"}}.
{comic_strip,{name,"Calvin and Hobbes"},
{character,"Spaceman Spiff"}}

24> Person = {person, {name, "Agent Smith"}, {profession, "Killing programs"}}.
{person,{name,"Agent Smith"},
{profession,"Killing programs"}}

Para obtener valores de la persona podemos hacer lo siguiente:

25> {person, {name, Name}, {profession, Profession}} = Person.
{person,{name,"Agent Smith"},
{profession,"Killing programs"}}
26> Name.
"Agent Smith"
27> Profession.
"Killing programs"

Se entiende? Obtenemos los valores en Name y Profession por medio de patrones de coincidencia.
Y con patrones de coincidencia se puede hacer más cosas:

28> [Head | Tail] = [1, 2, 3].
[1,2,3]
29> Head.
1
30> Tail.
[2,3]
32> [One, Two|Rest] = [1, 2, 3].
[1,2,3]
33> One.
1
34> Two.
2
35> Rest.
[3]

Si no hay suficientes elementos en la lista el patrón no funciona:

6> [X|Rest] = [].
** exception error: no match of right hand side value []

Erlang es dinámicamente tipado, Erlang puede enlazar tipos en runtime. Vamos a hacer una función para esto vamos a hacer un modulo. Yo uso debian pero para windows debe ser parecido.
Salimos del runtime Ctrl + G.
Escribimos:
nano basic.erl
En nano escribimos el siguiente código:

-module(basic).
-export([mirror/1]).
mirror(Anything) -> Anything.

Salimos y guardamos. Luego escribimos erl en la consola.
Y por ultimo compilamos:

1> c(basic).
{ok,basic}

La función mirror solo devuelve lo que pasamos como parámetro. Pueden ver que el operador -> simplifica el return.

5> mirror(smiling_mug).
** exception error: undefined shell command mirror/1
6> basic:mirror(smiling_mug).
smiling_mug
6> basic:mirror(1).
1
Vemos que hay que ingresar el nombre del modulo.

-module(matching_function).
-export([number/1]).
number(one) -> 1;
number(two) -> 2;
number(three) -> 3.

En la siguiente función se puede ver la influencia de Prolog en Erlang.
Por ultimo implementemos factorial y figonacci :

-module(yet_again).
-export([another_factorial/1]).
-export([another_fib/1]).
another_factorial(0) -> 1;
another_factorial(N) -> N * another_factorial(N-1).
another_fib(0) -> 1;
another_fib(1) -> 1;
another_fib(N) -> another_fib(N-1) + another_fib(N-2).

Hasta aca vimos muy por arriba Erlang en proximos post vamos a seguir hablando.

Dejo links:

jueves, 16 de diciembre de 2010

Google regala los productos de Instantiations a la Fundación Eclipse

Siempre quise programar en GWT ahora se me va a ser más fácil con los productos que google regalo a la comunidad de eclipse por ende a nosotros.

Google ha donado WindowBuilder Pro (que incluye Swing Designer, SWT Designer y GWT Designer) y CodePro Profiler a la comunidad de código abierto y que en la primera mitad de 2011 pasarán a ser nuevos proyectos de Eclipse.

Estos productos nos ayudan a desarrollar de forma fácil interfaces gráficas con java y eclipse.

Que grande google!!!

Dejo links:

http://googlecode.blogspot.com
http://code.google.com/javadevtools/eclipse-donation-faq.html.

miércoles, 15 de diciembre de 2010

Masterbranch

Masterbranch es una pagina que contiene los cv de los programadores que participan en proyectos de software libre.

Lo que hace es recorrer los repositorios buscando info de los commiters y de esta forma tiene un banco de cv de gente que programa y si queda duda mira los commit del repositorio.

Muy buena idea, la verdad; también tiene la opcional de registrarse.

Dejo el link:

http://www.masterbranch.com


jeje

domingo, 5 de diciembre de 2010

Clojure


Clojure es Lisp en JVM. Es decir entendiendo Clojure entenderemos List, y entendiendo List entenderemos Clojure. Después de Fortran, List es el lenguaje más viejo. List es un lenguaje funcional pero no es un lenguaje puramente funcional.

Una de las más importantes características de Clojure es que corre en la JVM.

Deben bajar la consola para Clojure de http://clojure.org/ y empecemos haciendo un Hola Mundo!

user=> (println "Hola Mundo!")
Hola Mundo!
nil


Veamos llamadas a funciones:

user=> (- 1)
-1
user=> (+ 1 1)
2
user=> (* 10 10)
100
user=> (mod 5 4)
1
user=> (/ (/ 12 2) (/ 6 2))
2
user=> (+ 2 2 2 2)
8
user=> (- 8 1 2)
5
user=> (/ 8 2 2)
2
user=> (+ 3.0 5)
8.0
user=> (+ 3 5.0)
8.0

Clojure maneja los tipos de java:

user=> (class true)
java.lang.Boolean
user=> (class (= 1 1))
java.lang.Boolean

Podemos usar el condicional:

user=> (if true (println "True it is."))
True it is.
nil
user=> (if false (println "true") (println "false"))
false
nil

Veamos las listas:
user=> (list 1 2 3)
(1 2 3)
user=> '(1 2 3)
(1 2 3)

vectores:
user=> [:hutt :wookie :ewok]
[:hutt :wookie :ewok]

Mapas:
user=> {:chewie :wookie :lea :human}
{:chewie :wookie, :lea :human}

Definir funciones:
user=> (defn force-it [] (str "Use the force," "Luke."))
#'user/force-it
y usarla:
user=> (force-it)
"Use the force,Luke."

Este es un pequeño y humilde paseo por Clojure, si deben aplicar programación funcional en una aplicación Java es la herramienta justa.

Dejo links:
http://clojure.org/

Io

Io es un lenguaje de programación prototipado inspirado en Smalltalk, Self, NewtonScript, Act1, LISP y Lua.

Io es prototipado. Existen varias formas de implementar la programación orientada a objetos, la más conocida es por medio de clases. La otra no tan conocida es por prototipos donde no nos preocupamos por las clases sino por los objetos, y estos objetos se pueden duplicar o clonar. De esta forma funciona la programación orientada a objetos en Javascript.

Veamos un hola mundo hecho en io, luego de instalarlo desde el siguiente sitio: http://iolanguage.com/
En la consola hacemos Io y luego escribimos:
“Hola mundo” print
Y va imprimir “Hola mundo”, como vemos el string envía un mensaje de que se imprima.

Veamos como crear un objeto:
Vehiculo := Object clone
Vehiculo no es una clase, sino es un objeto tipo “template” que se utiliza para crear otros objetos.
Vehiculo descripcion := “Es un vehiculo”
descripcion es una propiedad del Vehiculo. Las propiedades son vectores clave valor, similar a Javascript.

Y si ejecutas
Vehiculo descripcion
El resultado sera “Es un vehiculo” como era de esperar. En realidad un objeto es una lista que contiene propiedades y metodos.

Io> Vehiculo slotNames
==> list("type", "descripcion")

Como vemos el objeto tiene una propiedad tipo:

Io> Vehiculo type
==> Vehicle
Io> Object type
==> Object

Como podemos ver Vehiculo es un tipo, una idea que resalto es que los typos no son clases sino objetos. El objeto Vehiculo es un tipo.
Ahora vamos a construir un Auto usando herencia:

Io> Auto := Vehiculo clone
==> Auto_0x100473938:
type = "Auto"
Io> Auto slotNames
==> list("type")
Io> Auto type
==> Auto
Ahora vamos a hacer un ferrari B)

Io> ferrari := Auto clone
==> Auto_0x1004f43d0:
Io> ferrari slotNames
==> list()

ferrari no es un tipo, como sabe Io cual es un Tipo y cual no, por convención los tipos comienzan con mayúscula.

Io> ferrari type
==> Auto

Ni clases, ni modulos, ni interfaces, solo Objetos!

En Io es fácil hacer metodos:

Io> method("este es un metodo." println)
==> method(
“este es un metodo." println
)

Los metodos son objetos:

Io> method() type
==> Block

Podemos asignarle un metodo a el Auto
Io> Auto manejar := method("Manejando manejando voy!" println)
==> method(
"Manejando manejando voy!" println
)

Io es un lenguaje simple y potente que nos permite comprender como funcionan los lenguajes prototipados. Aprender Io nos ayuda a entender Javascript o Haskell.

Para mayor información ver: