Dejo un vídeo:
Dejo link:
https://www.edx.org/course/linuxfoundationx/linuxfoundationx-lfs101x-introduction-1621#.U9rn_x8zzpq
jueves, 31 de julio de 2014
Introduction to Linux
Dejo un vídeo:
Dejo link:
https://www.edx.org/course/linuxfoundationx/linuxfoundationx-lfs101x-introduction-1621#.U9rn_x8zzpq
Tutorial de Python en Español Por Python Argentina
La verdad es que estoy robando esta información a Chema Cortés, gracias a él encontré este excelente tutorial de Python hecho por la gente de Python Argentina.
Sin otro particular les dejo el link:
http://docs.python.org.ar/tutorial/index.html
martes, 29 de julio de 2014
OpenSUSE Factory se convierte en distro rolling release
Que buena distro OpenSUSE!!
OpenSUSE tiene una distro hermanita o hija OpenSUSE Factory que es la rama de desarrollo de OpenSUSE. Esta distro a optado por ser rolling release.
Sin más les presento esta distro:
"La distribución Factory es una distribución de desarrollo continuo (rolling) y la base para la próxima publicación estable de openSUSE.
Hay un flujo constante de paquetes entrando en Factory. No hay congelaciones y, por tanto, el repositorio Factory no ofrece garantías de ser completamente estable. Los paquetes fundamentales del sistema se testan usando openQA. Cuando se completa el test automatizado y el repositorio se encuentra en un estado estable, éste se sincroniza con los servidores réplica para la descarga. Esto sucede una o dos veces por semana.
Factory es mayormente útil para los desarrolladores principales de la distribución, testeadores con experiencia y desarrolladores que quieren estar al filo de la navaja.
Se avisa a los usuarios corrientes de que se mantengan en la versión estable. "
Dejo link:
http://es.opensuse.org/Portal:Factory
domingo, 27 de julio de 2014
Aprendiendo Node.js
Quiero compartir el siguiente libro que encontré sobre Node.js.
Dejo link: http://www.creativealys.com/2014/07/27/learning-node-js/
Desarrollo en Android y IOS con F#
F# ahora esta soportado para las plataformas Android y IOS gracias a la gente de Xamarin. A partir de la versión Xamarin 4.8 podemos utilizar F# para desarrollar aplicaciones Android y IOS. Les recuerdo que Xamarin es la empresa que llevo a C# a Android y la principal promotora de Mono.
Y para el que no sabe, F# (pronunciado F Sharp) es un lenguaje de programación multiparadigma de código abierto, para la plataforma .NET, que conjunta la programación funcional con las disciplinas imperativa y orientada a objetos. Es una variante del lenguaje de programación ML y es compatible con la implementación Objective Caml. F# fue inicialmente desarrollado por Don Syme de Microsoft Research, pero actualmente está siendo desarrollado por la División de Desarrolladores de Microsoft y es distribuido como un lenguaje totalmente soportado en la plataforma .NET y Visual Studio 2010, 2012 y 2013.
Dejo link:
http://www.infoq.com/news/2014/07/fsharp-native-moible-development
martes, 22 de julio de 2014
Programación con Qt4
- Advanced Qt Programming Creating Great Software with C++ and Qt 4
- An Introduction to Design Patterns in C++ with Qt
- C++ GUI Programming with Qt 4
- Foundations of Qt Development
Les dejo el link:
Introduction to Multitenant Databases
Me llego un mail de la gente de oracle invitandome a un Webinar. Parece interesante por lo tanto quiero compartir la invitación:
|
domingo, 20 de julio de 2014
Lista por comprensión
¿Recuerdan de las definiciones matemáticas de por ejemplo números pares o múltiplos que veíamos en la escuela? por ejemplo la definición de los números pares mayores a 10 sería así:
s = { 2 * x | x € N, 2 * x > 10 }
Esto se lee como los números pares (2*x) que pertenecen (€) a los números naturales (N) y que sean mayores que 10. La parte anterior al separador se llama la función de salida, x es la variable, N es el conjunto de entrada y 2 * x > 10 es el predicado.
De esta forma se define la lista de forma compresiva. Es decir se puede conocer el valor de la lista dependiendo de la posición sin enumerar sus elementos. Esta definición se podría escribir en Haskell de la siguiente manera:
s = [ 2*x | x <- [0..], x*2 > 10 ]
Como vemos es muy similar a la definición matemática, solo que se define los números naturales como [0..] los dos puntos indican que esta lista es infinita. Cuando pensamos en una lista infinita, automáticamente relacionamos con un bucle que nunca termina o con un cuelgue de nuestro programa, esto es porque venimos del mundo imperativo pero cómo Haskell ejecuta las sentencias de forma perezosa, podemos modelar listas infinitas sin problema.
Podemos modelar diferentes listas sin ningún problema, por ejemplo todos los números del 50 al 100 cuyo resto al dividir por 7 fuera 3 :
ghci> [ x | x <- [50..100], x `mod` 7 == 3]
[52,59,66,73,80,87,94]
La lista de dobles de los números naturales y que el cuadrado sea mayor a 3:
s = [ 2*x | x <- [0..], x^2 > 3 ]
Por suerte las listas por compresión, no son solo una característica de Haskell sino que se encuentra en diferentes lenguajes, voy a mostrar el ejemplo de la lista de dobles de los números naturales y que el cuadrado sea mayor a 3 en diferentes lenguajes:
Ceylon
{ for (x in 0..100) if ( x**2 > 3) x * 2 }
Clojure
(take 20
(for [x (range) :when (> (* x x) 3)]
(* 2 x)))
;; ⇒ (4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42)
CoffeeScript
(x * 2 for x in [0..20] when x*x > 3)
Elixir
for x <- 0..100, x*x > 3, do: x*2
Erlang
S = [2*X || X <- lists:seq(0,100), X*X > 3].
F#
> seq { for x in 0..100 do
if x*x > 3 then yield 2*x } ;;
val it : seq<int> = seq [4; 6; 8; 10; ...]
Groovy
s = (1..100).grep { it ** 2 > 3 }.collect { it * 2 }
s = (1..100).grep { x -> x ** 2 > 3 }.collect { x -> x * 2 }
JavaScript 1.7
js> [2*x for each (x in [0,1,2,3,4,5,6,7]) if (x*x<5)]
[0, 2, 4]
Julia
y = [x^2+1 for x in 1:100]
Perl 6
my @s = ($_ * 2 if $_ ** 2 > 3 for ^100);
Python
S = [2 * x for x in range(101) if x ** 2 > 3]
Scala
val s = for (x <- Stream.from(0) if x*x > 3) yield 2*x
Smalltalk
((1 to: 100) select: [:x|x*x>3]) collect: [:x|2*x]
Algunos lenguajes tienen diferentes formas de hacer lo mismo y para algunos lenguajes no uso todos los números naturales sino hasta el 100.
En resumen podemos decir que las listas por comprensión es una característica de algunos lenguajes con lo cual podemos definir listas de forma comprensiva.
Dejo link: http://en.wikipedia.org/wiki/List_comprehension
jueves, 17 de julio de 2014
Eclipse Luna esta aquí!!
Dejo link: http://www.eclipse.org/
miércoles, 16 de julio de 2014
Resolviendo problemas de forma funcional
Pensar de forma funcional es bastante difícil y más que nada si estamos programando en otro paradigma. Por lo tanto la idea es plantear un problema y buscar una solución funcional.
Problema
Normalmente cuando escribíamos expresiones matemáticas en la escuela lo hacíamos de forma infija. Por ejemplo, 10 -(4 + 3) * 2. +, * y - son operadores infijos. Resulta bastante útil, ya que nosotros, como humanos, podemos analizar fácilmente estas expresiones. Lo malo es que tenemos que utilizar paréntesis para especificar la precedencia.
La Notación polaca inversa (RPN) es otra forma de escribir expresiones matemáticas. Al principio parece un poco complicado, pero en realidad es bastante fácil de entender y utilizar ya que no hay necesidad de utilizar paréntesis y muy fácil de utilizar en la calculadoras. Aunque las calculadoras más modernas usan una notación infija, todavía hay gente que lleva calculadoras RPN (del inglés, Reverse Polish Notation). Así se vería la expresión infija anterior en RPN:
10 4 3 + 2 * -
¿Cómo calculamos el resultado de esto? Bueno, piensa en una pila. Recorremos la expresión de izquierda a derecha. Cada vez que encontramos un número, lo apilamos. Cuando encontramos un operador, retiramos los dos números que hay en la cima de la pila, utilizamos el operador con ellos y apilamos el resultado de nuevo. Cuando alcancemos el final de la expresión, debemos tener un solo número en la pila si la expresión estaba bien formada, y éste representa el resultado de la expresión.
Si no estas pensando en Lisp, no tuviste infancia o tuviste una infancia feliz. En Lisp, el primer elemento de cada expresión es un operador y el resto de elementos son tratados como datos. Esta forma se denomina notación prefija o notación Polaca Cambridge. Lisp no utiliza la notación polaca inversa, usa la notación prefija de esta forma tampoco es necesario especificar la precedencia.
Pero sigamos con el problema, vamos a pensar en como podríamos hacer que una función tomara como parámetro una cadena que contenga una expresión RPN, como 10 4 3 + 2 * -, y nos devolviera el resultado.
Solución
Antes que nada para trabajar más cómodos necesitamos una lista que contenga los operadores y operandos, por lo tanto debemos tomar la cadena “10 4 3 + 2 * -” y separarla por los espacios y luego llevarla a una lista.Cuando implementemos la solución de un problema, a veces es bueno ver como lo solucionamos de forma manual para ver si podemos sacar algo que nos ayude. Por lo tanto vamos a resolver la expresión “10 4 3 + 2 * -” de forma manual.
Como dijimos anteriormente llevamos “10 4 3 + 2 * -” a una lista. Luego tomamos el primer elemento y lo apilamos de forma que ahora nuestra pila contiene un 10. El siguiente elemento es un 4, así que lo apilamos también. La pila ahora contiene 10, 4. Hacemos los mismo para el 3 y conseguimos una pila que contiene 10, 4, 3. Ahora, encontramos un operador, +. Retiramos los dos números que se encuentran en la cima de la pila (de forma que la pila se quedaría de nuevo solo con 10), sumamos esos dos números y apilamos el resultado. La pila contiene 10, 7 ahora mismo. Apilamos 2 y obtenemos 10, 7, 2. Multiplicamos 7 y 2 y obtenemos 14, así que lo apilamos y la pila ahora contendrá 10, 14. Para terminar hay un -. Retiramos 10 y 14 de la pila, restamos 14 a 10 y apilamos el resultado. El número que contiene la pila es -4 y como no hay más números ni operadores en la expresión, ese es el resultado.
Lo primero que podemos pensar es en los casos especiales, ¿que deberíamos hacer si la lista de operadores y operandos esta vacía? En ese caso deberíamos devolver la pila, la pila debería tener un elemento, pero esta validación escapa del ejercicio. Si tiene un elemento debemos analizar que es ese elemento si es un operador debemos tomar los dos elementos de la pila, luego aplicar el operador y por ultimo apilar el resultado. Si es un operando debemos simplemente apilarlo.
Una cosa más que tenemos que pensar es, bueno ¿Cómo vamos a representar la pila? Propongo que utilicemos una lista. También propongo que mantengamos en la cabeza de la lista la cima de la pila. De esta forma añadir un elemento en la cabeza de la lista es mucho más eficiente que añadirlo al final. Así que si tenemos una pila como, 10, 4, 3, la representaremos con una lista como [3,4,10].
Ahora tenemos suficiente información para bosquejar vagamente nuestra función. Tomará una cadena como "10 4 3 + 2 * -" y la romperá en una lista de elementos utilizando words de forma que obtenga ["10","4","3","+","2","*","-"]. Luego, utilizará un pliegue por la izquierda sobre esa lista y generará una pila con un único elemento, como [-4]. Tomará ese único elemento de la lista y ese será nuestro resultado final.
Veamos el código en scala:
//Paso la cadena a una lista
val valores = "10 4 3 + 2 * -".split(" +").toList
def eval(valores : List[String], pila:List[String]) : List[String] = valores match {
case Nil => pila
case x :: xs => x match {
case "+" => eval(xs, (pila(1).toInt + pila.head.toInt).toString :: pila.tail.tail)
case "-" => eval(xs, (pila(1).toInt - pila.head.toInt).toString :: pila.tail.tail)
case "*" => eval(xs, (pila(1).toInt * pila.head.toInt).toString :: pila.tail.tail)
case _ => eval(xs, x :: pila )
}
}
eval(valores, Nil)
> res0: List[String] = List(-4)
Como podemos ver usando funciones recursivas podemos recorrer la lista con operadores y operandos.
Otra forma de recorrer una lista muy fácilmente es por medio de los pliegues. Con los pliegues podemos implementar cualquier función que recorra una lista de izquierda a derecha, elemento a elemento, y genere (o acumule) un resultado.
En este caso, vamos a utilizar un pliegue por la izquierda, ya que vamos a recorrer la lista de izquierda a derecha.
Veamos la solución con pliegues:
def eval2(pila:List[String], x: String) : List[String] = x match {
case "+" => (pila(1).toInt + pila.head.toInt).toString :: pila.tail.tail
case "-" => (pila(1).toInt - pila.head.toInt).toString :: pila.tail.tail
case "*" => (pila(1).toInt * pila.head.toInt).toString :: pila.tail.tail
case _ => x :: pila
}
valores.foldLeft(List[String]()) (eval2)
> res1: List[String] = List(-4)
o la versión resumida usando clausuras:
"10 4 3 + 2 * -".split(" +").toList.foldLeft(List[String]()) ((pila:List[String], x: String) => x match {
case "+" => (pila(1).toInt + pila.head.toInt).toString :: pila.tail.tail
case "-" => (pila(1).toInt - pila.head.toInt).toString :: pila.tail.tail
case "*" => (pila(1).toInt * pila.head.toInt).toString :: pila.tail.tail
case _ => x :: pila
})
Como ven podemos resolver el problema utilizando pattern matching y pliegues o funciones recursivas.
Que opinan? se puede mejorar la solución?
Developing Android Apps
Les dejo un vídeo:
Dejo link:
https://www.udacity.com/course/ud853
martes, 15 de julio de 2014
Debian AIO: todos los sabores de Debian en un solo disco
Robe este post, es de http://lamiradadelreplicante.com/
Quiero hacerme eco de esta super version de Debian que permite probar todos los sabores del sistema operativo. Debian Live AIO DVD es un proyecto no oficial de Debian que incluye todas las ISOs de los principales entornos presentes en esta distribución GNU/Linux, como son KDE, GNOME, Xfce y LXDE, en un único archivo.
Dejo el link, del post original:
http://lamiradadelreplicante.com/2014/07/14/debian-aio-todos-los-sabores-de-debian-en-un-solo-disco/
domingo, 13 de julio de 2014
sábado, 12 de julio de 2014
Entendiendo el principio HATEOAS
HATEOAS es la abreviación de Hypermedia as the Engine of Application State (hipermedia como motor del estado de la aplicación). Es una restricción de la arquitectura de la aplicación REST que lo distingue de la mayoría de otras arquitecturas. El principio es que un cliente interactúa con una aplicación de red completamente a través de hipermedia proporcionadas dinámicamente por los servidores de aplicaciones. Es como que el cliente REST debe ir navegando por la información y no necesita ningún conocimiento previo acerca de la forma de interactuar con cualquier aplicación o servidor más allá de una comprensión genérica de hipermedia.
En otras palabras cuando el servidor nos devuelva la representación de un recurso parte de la información devuelta serán identificadores únicos en forma de hipervínculos a otros recursos asociados.
Lo vamos a entender mejor con un ejemplo, supongamos que tenemos una API REST, con cliente y sus diferentes pedidos. El modelo podría ser un cliente que tenga una lista de pedidos.
Lo que podríamos hacer es cuando el cliente REST solicite un cliente por la URI:
myURL/cliente/:id
Devolvemos los datos del cliente con su lista de pedidos. Pero el problema yace en que tal vez tenga muchos pedidos y a la vez el cliente REST necesita datos del cliente no de los pedidos. Por lo tanto, estoy mostrando más información de lo que debiera.
Una solución sería tener otro servicio REST que me devuelva los pedidos, por ejemplo:
myURI/cliente/2
Esta URI me devolverá los datos del cliente 2 que podría ser:
{ id:2, nombre:”Pepe”, apellido:”Gomez” }
Y podríamos hacer otro servicio que nos devuelva los pedidos por medio de la URI:
myURI/cliente/2/pedidos
Supongamos que por algún problema debemos cambiar la URI de pedidos, para hacer esto debemos avisar a todos los clientes y ellos deberán consumir la nueva URI.
HATEOAS nos dice que debemos mostrar las URIs de forma que el cliente este menos acoplado al servidor y no sea necesario hacer cambios en estos casos.
Por ejemplo el servicio de consulta de clientes puede devolver la URI del pedido de la siguiente manera:
{ id:2, nombre:”Pepe”, apellido:”Gomez” , pedidos:”myURL/cliente/2/pedidos ”}
A la vez si no mostramos la URI de los pedidos el cliente REST tiene que ir a la documentación de la API por cada servicio que desee utilizar. Con HATEOAS los servicios descubren nuevos servicios lo que permite navegar por la información y un cliente que una URI principal puede ir descubriendo los demás servicios.
La restricción HATEOAS desacopla cliente y el servidor de una manera que permite la funcionalidad del servidor para evolucionar de forma independiente.
Dejo link: http://en.wikipedia.org/wiki/HATEOAS
Mint Xfce
Todos sabrán mi adoración por el sistema operativo Mint, me parece que hace las cosas muy bien y me gusta mucho la interfaces mate y cinammon. Pero ahora les quiero mostrar Mint xfce. Para el que no conoce xfce es una interfaces de escritorio muy liviana y potente, la que la gente de Mint la volvió muy elegante.
Les cuento tal cual fue mi encuentro con esta versión, andaba buscando un escritorio liviano para una pc vieja que tengo y siendo sincero quede maravillado, tanto que lo voy a usar en mi actual pc.
Les dejo screenshots:
Dejo link:
http://www.linuxmint.com/
Les cuento tal cual fue mi encuentro con esta versión, andaba buscando un escritorio liviano para una pc vieja que tengo y siendo sincero quede maravillado, tanto que lo voy a usar en mi actual pc.
Les dejo screenshots:
Dejo link:
http://www.linuxmint.com/
jueves, 10 de julio de 2014
Bootstrap 3, el manual oficial
Bootstrap 3 es un framework front-end para desarrollo web, enfocado en responsive design. Si no lo conoces deberías hacerlo ya que es de gran utilidad.
Me encontré este manual que me pareció bien compartirlo:
http://librosweb.es/bootstrap_3/
A estudiar!!!
martes, 8 de julio de 2014
Hacer una Api Rest con haskell es posible gracias a rest
Parece un juego de palabras pero no lo es rest es un framework (en la documentación dice conjunto de paquetes) que permiten hacer una Api Rest con Haskell.
A la vez se puede ejecutar estas librerías en varios frameworks web, como Happstack o Snap. También puede generar automáticamente la documentación de la API Rest, lo que garantiza que siempre coincide con el código. Del mismo modo, puede generar cliente para diferentes lenguajes como Javascript o Haskell.
Algo muy bueno es que la Api queda escrita como en un DSL muy fácil de mantener, veamos un ejemplo:
module Api.Post (resource) where
import Rest
import qualified Rest.Resource as R
type Title = String
resource :: Resource IO (ReaderT Title IO) Title () Void
resource = mkResourceReader
{ R.name = "post"
, R.schema = withListing () $ named [("title", singleBy id)]
, R.list = const list
, R.get = Just get
}
Dejo link:
http://silkapp.github.io/rest/
https://github.com/silkapp/rest/archive/master.zip
sábado, 5 de julio de 2014
The Eclipse Memory Analyze, una excelente herramienta para buscar memory leak
Si no sabes que es un memory leak siéntete un afortunado, dado que estos nos hacen la vida imposible cuando suceden. Como sabrán java tiene un Garbage collector o recolector de basura que se encarga de eliminar los objetos que no utilizamos y liberar la memoria.
Pero cómo sabe cuándo no usamos más un objeto? Una posibilidad es cuando nadie lo referencia. En el heap de la Máquina Virtual Java (JVM) guarda todos los objetos creados por la aplicación Java, por ejemplo, utilizando el operador "new". El recolector de basura de Java puede separar lógicamente el heap en diferentes áreas, por lo que el garbage collector puede rápidamente identificar los objetos que pueden quedar eliminados.
La memoria para los nuevos objetos se asigna en el heap en tiempo de ejecución. Las variables de instancia viven en el interior del objeto en el que se han declarado. Por lo tanto, si referenciamos siempre a un objeto por más que no lo usemos el garbage collector no lo va a poder eliminar. Si creamos objetos y no los liberamos nunca vamos a consumir cada vez más memoria y este es un recurso limitado por lo que tarde o temprano vamos a tener un OutOfMemoryError. Es decir nos, quedamos sin memoria.
Algo horrendo en la vida de un programador, es buscar este tipo de errores. Son muy difíciles de rastrear y muchas veces ocurren cuando la aplicación tiene tiempo corriendo.
Para ayudarnos a luchar contra los memory leak, eclipse creo MAT o The Eclipse Memory Analyze que es un rápido y seguro analizador de memoria java. Que necesitamos para utilizarlo? Solamente un dump de memoria cuando ocurra el error. Si, si claro y como obtengo esto?
Es muy fácil, para obtener un dump de memoria cuando ocurre un OutOfMemoryError debemos configurar la jvm con unos parámetros como lo indica la documentación de oracle:
-XX:-HeapDumpOnOutOfMemoryError que indica a la Jvm que haga un dump cuando ocurra un OutOfMemoryError
-XX:HeapDumpPath=./java_pid<pid>.hprof que indica donde va a guardarse el dump, no es obligatorio pero es aconsejable configurar el path para estar seguros donde se va a guardar.
Por ejemplo con:
Java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/home/emanuelpeg/logs/
Le estoy diciendo a la jvm que guarde el dump de memoria en /home/emanuelpeg/logs/ cuando ocurra un OutOfMemoryError.
Luego de esto es todo muy fácil, solo tenemos que importar el dump a MAT y esta herramienta nos preguntará si queremos hacer un reporte con los memory leaks y simplemente tenemos que presionar finish para obtener un completo reporte interactivo de la memoria de la jvm.
A la vez nos brinda gráficos con los posibles errores, y contiene un histograma el cual muestra el número de instancias de una clase en particular y la cantidad de memoria que cada uno utiliza. Además, se puede agrupar por cargador de clase o paquete. Esto le permitirá centrarnos en nuestros objetos.
Como conclusión podemos asegurar que MAT es una herramienta indispensable para la búsqueda de memory leaks.
Dejo link: http://www.eclipse.org/mat/
viernes, 4 de julio de 2014
jueves, 3 de julio de 2014
Scala.js
Scala.js es un compilador scala a javascript. Con este compilador podemos escribir nuestras paginas en Scala y ejecutarlas en nuestro browser preferido. Entre las características más importantes podemos nombrar:
- Soporte total de scala (hasta macros)
- Muy buena interoperabilidad con javascript.
- Integración con Sbt
- Puede utilizar la IDE que prefiera para programar en Scala
Dejo link:
Suscribirse a:
Entradas (Atom)
