Quiero compartir estos vídeo tutoriales sobre django el framework más popular para desarrollo de aplicaciones web para python.
Dejo link: https://www.youtube.com/playlist?list=PLEtcGQaT56cg3A3r-TNoc-PyVeOuAMB4x
martes, 5 de agosto de 2014
Curso de Django
Quiero compartir estos vídeo tutoriales sobre django el framework más popular para desarrollo de aplicaciones web para python.
Dejo link: https://www.youtube.com/playlist?list=PLEtcGQaT56cg3A3r-TNoc-PyVeOuAMB4x
sábado, 2 de agosto de 2014
Comet fácil con Atmosphere Framework
Seguramente has sentido nombrar la técnica de comet o técnica de Push que permite que el servidor envié peticiones sin que el browser o cliente lo solicite. Voy a dar un ejemplo, si debemos implementar un chat, en el modelo tradicional el cliente debe preguntar cada cierto tiempo si hay un nuevo mensaje para él porque el servidor no puede notificar al cliente sin un pedido de éste.
El enfoque comet difiere del modelo original de la web, en el que un navegador solicita una página web completa o trozos de datos para actualizar una página web. En cambio, el servidor puede notificar al cliente sin que él haya hecho un pedido, pero esto es solo en teoría porque en la práctica hay diferentes formas de implementar comet, una muy extendida es que el cliente haga pedidos largos y el servidor solo conteste cuando tenga algo que notificar, otro modo es utilizar WebSocket si utilizamos HTML 5.
Atmosphere es un framework java/javascript para la construcción de aplicaciones Web asincrónicas usando Groovy, Scala y Java. El objetivo del framework es permitir a los desarrolladores escribir una aplicación y dejar que éste descubra el mejor canal de comunicación entre el cliente y el servidor, de forma transparente. Por ejemplo, con atmophere una aplicación puede utilizar webSockets cuando el servidor y el browser lo permitan pero éste framework usara otra técnica si esto no esta soportado.
Del lado del servidor atmophere soporta Tomcat, Jboss, Jetty, Resin, GlassFish, Undertow, WebSphere, WebLogic etc. pero si no corres tu aplicación sobre un servlet container tienes soporte para Netty, Play! Framework o Vert.x. Además tiene extensiones para los frameworks más usados PrimeFaces, Wicket, Vaadin, Grails, richfaces, Spring, etc. Puedes buscar la extensión que necesites aquí.
Si utilizas maven puedes utilizarlo agregando la siguiente dependencia:
<dependency>
<groupId>org.atmosphere</groupId>
<artifactId>atmosphere-{atmosphere-module}</artifactId>
<version>2.2.0</version>
</dependency>
Atmosphere es una excelente opción para implementar la técnica de comet en Java por su flexibilidad, integración y facilidad de uso.
Dejo links:
https://github.com/Atmosphere/atmosphere
http://async-io.org/
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
Suscribirse a:
Entradas (Atom)
