Libros de programación gratuitos

Un montón de libros sobre programación y lenguajes lo encontraran en el siguiente link:
http://www.onlineprogrammingbooks.com/

Getting Started with DB2 Express-C

DB2 Universal Database es el sistema de administración de bases de datos que brinda una plataforma de base de datos flexible y efectiva en costos para construir aplicaciones robustas de negocios on demand.

Esto es lo que nos indica IBM en su pagina, tambien existe una versión express de la base de datos llamada DB2 Express-C, esta buena, lo que quiero compartir es un libro gratuito sobre esta base.

Dejo link:
http://www.ibm.com/developerworks/wikis/display/DB2/FREE+Book-+Getting+Started+with+DB2+Express-C

Visualizador de código Python online

Los que están aprendiendo a programar y los que estamos aprendiendo python, es de mucha ayuda ver que esta sucediendo cuando corremos el código. Les dejo un vizualisador en el que se puede ver los valores de las variables y como ejecuta el programa linea por linea.

Dejo una pantalla de ejemplo:

Dejo link:
http://pythontutor.com/visualize.html

doctest, Usando la documentación para testear.

Me encontré con este framework de python y la verdad que quede sorprendido, su facilidad de uso y pragmatismo. La idea es que cuando realizamos funciones debemos documentarlas, que no mejor que luego de documentarla dejar un ejemplo de como funciona y el resultado que devuelve la función. Bueno la idea de este framework es utilizar esta documentación para testear nuestra función.

Veamos un ejemplo:

"""
This is the "example" module.

The example module supplies one function, factorial().  For example,

>>> factorial(5)
120
"""

def factorial(n):
    """Return the factorial of n, an exact integer >= 0.

    >>> [factorial(n) for n in range(6)]
    [1, 1, 2, 6, 24, 120]
    >>> factorial(30)
    265252859812191058636308480000000
    >>> factorial(-1)
    Traceback (most recent call last):
        ...
    ValueError: n must be >= 0

    Factorials of floats are OK, but the float must be an exact integer:
    >>> factorial(30.1)
    Traceback (most recent call last):
        ...
    ValueError: n must be exact integer
    >>> factorial(30.0)
    265252859812191058636308480000000

    It must also not be ridiculously large:
    >>> factorial(1e100)
    Traceback (most recent call last):
        ...
    OverflowError: n too large
    """

    import math
    if not n >= 0:
        raise ValueError("n must be >= 0")
    if math.floor(n) != n:
        raise ValueError("n must be exact integer")
    if n+1 == n:  # catch a value like 1e300
        raise OverflowError("n too large")
    result = 1
    factor = 2
    while factor <= n:
        result *= factor
        factor += 1
    return result


if __name__ == "__main__":
    import doctest
    doctest.testmod()

Como vemos en el ejemplo se creo una funcion factorial y se la documento con ejemplos de uso, luego al final de la función se indico que si se corre este modulo como programa principal, se corran los test. Por lo tanto si hacemos:

python example.py -v

La "-v" es para que doctest devuelva una salida. Con la ejecución de esta linea de código se correrán los ejemplos de la documentación devolviendo los siguientes valores:


Trying:
    factorial(5)
Expecting:
    120
ok
Trying:
    [factorial(n) for n in range(6)]
Expecting:
    [1, 1, 2, 6, 24, 120]
ok


Es genial!! Me parece una gran idea, que mal que no lo haya conocido antes. Existe un port para java que se llama doctestj; tendremos que probarlo.

Dejo link:
http://docs.python.org/3.3/library/doctest.html
https://code.google.com/p/doctestj/

Taller gratuito de introducción a Python

Este taller gratuito te servirá para dar los primeros pasos en Python, un lenguaje de programación multiplataforma y de propósito general que tiene diversas particularidades que lo hacen especial. Python es interpretado y está pensado para que tenga una sintaxis ligera y limpia, lo que lo hace sencillo de aprender.

Así comienza a describir el curso gratuito realizado por escuela It. Vamos a tener que inscribirnos, ojo comienza el 1 de abril.

Dejo link:
http://escuela.it/cursos/taller-python/

putty y Xming, una potencia!!

Les explico en el trabajo tenemos varios linux y clientes windows (un clásico); y nos conectamos con ssh a los servers; ssh tiene la opción -x que permite desplegar aplicaciones gráficas en el cliente.   Bueno si hacemos ssh -x en linux y queremos ejecutar por ejemplo firefox funciona excelentemente; pero si lo hacemos desde windows, no funciona y es esperable.

Por lo tanto hay que instalar Xming que es un permite ver ventanas de linux en windows. Es decir yo puedo utilizar nautilus desde mi ventana de windows y anda que da calambre.

Dejo link:
http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html
http://sourceforge.net/projects/xming/
http://www.straightrunning.com/XmingNotes/

getVarName y para que quisiera saber el nombre de la variable?

Ojo lo que van a leer, no es real! No me tomen tan en serio. Se me ocurrió una idea bastante loca, pero va la tiro; a ver que opinión recibo. Porque algún lenguaje o uno nuevo crea o tiene un método que nos indique el nombre de la variable que usamos?

Onda:

String nombre = getVarName(pepe)
print(nombre) // Aca imprime pepe

Es una idea revolucionaria, pero para que la puedo llegar a usar?

Supongamos los mapas, que necesito una key para referenciar un valor bueno podría hacer algo así:

String variable1 = "hola mundo"
miMapa.put(getVarName(variable1), variable1)

Entonces cuando quiero saber el valor puedo hacer:

print(miMapa.get(getVarName(variable1))) // Acá imprimiría "hola mundo"

Esto a pesar que suene loco es bastante fácil de implementar con las macros del lenguaje. Se acuerdan de las macros? Las macros son instrucciones que le damos al compilador. Si nos fijamos en la wiki nos dira:

"Con el fin de evitar al programador la tediosa repetición de partes idénticas de un programa, los ensambladores y compiladores cuentan con macroprocesadores que permiten definir una abreviatura para representar una parte de un programa y utilizar esa abreviatura cuantas veces sea necesario. Para utilizar una macro, primero hay que declararla. En la declaración se establece el nombre que se le dará a la macro y el conjunto de instrucciones que representará."

Por ejemplo le podemos decir "che mira antes de compilar pasa por todo el código y donde veas getVarName(nombreDeUnaVariable) vos pone el string "nombreDeUnaVariable". Y listo!

Ahora llega el momento en que flasheo, que tal si se puede implementar orientado a objeto?? En este hipotético caso no se me ocurre una implementación. Pero supongamos que se pueda, puede ser un método de Object todos heredar de Object y listo. Lo bueno es que lo puedo sobrescribir. Por ejemplo quiero llenar otro mapa con objetos de la clase persona (supongamos) entonces puedo hacer esto.

class Persona
      Integer id

      String getVarName()
               String varName = super.getVarName()
               return varName + " " + id
end

En fin con esto puedo hacer algo así:

List personas = getPersonasFromDB();
for (Persona persona in personas)
      mapaDePersonas.put(persona.getVarName(), persona)

En realidad podemos modificar el mapa para que haga mapaDePersonas.put(persona) y ya nos tome el nombre de la variable...

for (String p in mapaDePersonas.keys())
     print(p) // aca imprime persona 1, persona 2, etc...

Y lo mejor de todo es que podria hacer:

 class Persona
      String getVarName()
               String varName = super.getVarName()
               return varName.changeCar("_", " ").upperFirstLetter() + " es mi nombre!"
end

piñon_fijo = Persona.new()

print(piñon_fijo) // y aca imprime "Piñon fijo es mi nombre!"

Que les parece la idea?? Saben si a alguien se le ocurrió antes? se les ocurre otro uso? Les gusto el ejemplo de Piñon Fijo??

coderace.me

Aprende programación jugando! Que buena onda! El objetivo es aprender a programar, pero mientras lo hacemos podemos divertirnos. Esta pagina nos ofrece un juego de carrera que va premiándonos mientras hacemos las cosas bien.

Dejo un vídeo:

Dejo el link:
http://coderace.me

Discover DevTools

Code School abrió un curso gratuito llamado Discover DevTools, en el curso se muestran herramientas de desarrollo web y esta auspiciado por google.

Dejo link:
http://www.codeschool.com/courses/discover-devtools

Welcome to the Principles of Functional Programming in Scala class!

Me llego el mail de comienzo del curso de Programación funcional en scala, en realidad comienza el  25 de este mes, este curso es muy recomendable. Y ojo no es fácil, pero vale la pena.

Dejo link:
https://www.coursera.org/course/progfun

Xtend 2.4

Ya hable de Xtend hace tiempo... 

Hace tiempo que no teníamos noticia pero ahora tenemos una nueva versión que tiene muchas novedades. Una de las más importantes es que podemos utilizar este lenguaje para escribir aplicaciones android, si android. Además:

• NuevAnotaciones activas. La nueva característica de anotación activa en Xtend se basa en anotaciones Java y permite participar en el proceso de traducción de código fuente a código fuente Xtend Java. as características del lenguaje.
• Xtend para el IDE de Eclipse ha sido mejorado, proporcionando un mejor soporte de herramientas de desarrollador de otros idiomas JVM. Esta nueva versión incluye las importaciones, extraer refactorización método, formateador, asistencia mejoradas de contenido, y mucho más. 
• El plugin Xtend para el IDE de Eclipse ha sido mejorado, proporcionando un mejor soporte de herramientas de desarrollador de otros idiomas JVM.
• Anotaciones activas. La nueva característica de anotación activa en Xtend se basa en anotaciones Java y permite participar en el proceso de traducción de código fuente a código fuente Xtend Java.
• Y más!!

Y que más queres? hace todo!

Dejo link:
http://www.eclipse.org/xtend/

Scala IDE 3.0.0 final

Si señores después de un año de desarrollo Scala IDE 3.0.0 esta aquí! Que trae esta nueva versión:

• Un depurador para Scala
• Más herramientas de refactoring
• Generador de código
• Un editor más rápido 
• Más colores, semantica resaltada, hipervinculos en los tipos, etc...
• Y más!!

Ya vamos descargando!!

Dejo link:
http://scala-ide.org/blog/3.0-final-announcement.html

Que es Node.js?

Es así el motor javascript V8, el motor que utiliza chrome; inspiro a hacer un entorno de programación en el lado servidor orientada a eventos. Es decir con javascript podemos programar del lado cliente y servidor. Fue creado con el enfoque de ser útil en la creación de programas de red altamente escalables, como por ejemplo, servidores web. Fue creado por Ryan Dahl en 2009, y su evolución está apadrinada por la empresa Joyent.

Dejo una infografía sobre Node.js:

Dejo link:

http://nodejs.org/

Primeros pasos con Play! Part 5

Y luego de un descanso seguimos aprendiendo play framework. Recuerden que nos habíamos quedado acá:

http://emanuelpeg.blogspot.com.ar/2013/02/primeros-pasos-con-play-part-4.html

Nos habíamos quedado en crear el modelo de Algo:

package models

case class Algo (id: Long, nombre: String, descripcion: String)

object Algo {
 
  def all(): List[Algo] = Nil
 
  def create(nombre: String, descripcion: String) {}
 
  def delete(id: Long) {}
 
}

Bueno creamos la case class Algo que nos sirve de modelo y luego un Objeto que va a realizar las tareas de listar, crear y borrar. Por ahora es un Objeto Dummy, onda que no hace nada pero luego vamos a implementar su interacción con la base de datos.

Para el que no este familiarizado con case class de scala puede leer esto: http://www.scala-lang.org/node/107.

Ahora vamos a hacer la pagina principal:


@(algos: List[Algo], algoForm: Form[String])

@import helper._

@main("Todo list") {
   
    <h1>@algos.size algo(s)</h1>
   
    <ul>
        @algos.map { algo =>
            <li>
                @algo.nombre
               
                @form(routes.Algo.delete(algo.id)) {
                    <input type="submit" value="Delete">
                }
            </li>
        }
    </ul>
   
    <h2>Add a new Algo</h2>
   
    @form(routes.Algo.newAlgo) {
       
        @inputText(algoForm("Nombre"))
       
        @inputText(algoForm("Descripcion"))
       
        <input type="submit" value="Create">
       
    }
   
}

Vamos a explicar un poquito, al principio declaramos una lista de Algo y un formulario; luego imprimimos cuantos algos hay y generamos un listado; permitiendo que se puedan eleminar; y para finalizar permitimos crear nuevos algos.

También importamos helper._ el cual nos ayuda a la creación de formularios. Normalmente un formulario crea un <form> de html.

Ahora vamos al controller a decirle que muestre nuestra nueva pagina:



package controllers

import play.api._
import play.api.mvc._

import play.api.data._
import play.api.data.Forms._

object Algo extends Controller {

  def index = Action {
    val algoForm = Form(
      "Nombre" -> nonEmptyText)
    Ok(views.html.algoIndex(models.Algo.all() ,algoForm))
  }

  def newAlgo = TODO

  def delete(id: Long) = TODO

}


Como vemos hemos hecho un formulario y le dijimos que nombre es requerido. Además que vaya a nuestra pagina.

Si vamos a http://localhost:9000/algo veremos la siguiente pagina:

Hermosa salvo porque todavía no guarda en la base de datos... Pero esto será en el próximo post!

Nuevo versión de Ceylon!!

Si señores Ceylon M5 es ta aquí!! y que nos podemos encontrar en esta nueva versión?

Bueno esta versión viene con varias novedades, por ejemplo las tuplas, interacción directa con javascript, el operador : , verbatim strings (que seria en castellano como cadenas textuales) , tipos de parámetros por defecto, nuevos módulos como ceylon.time para las fechas y ceylon.net.httpd; y más y más!!

A medida que vaya aprendiendo las nuevas características las posteo.

Dejo links:
http://ceylon-lang.org/documentation/1.0/roadmap/#milestone_5_done
http://ceylon-lang.org/blog/2013/02/15/progress-report/