sábado, 25 de febrero de 2017

Un resumen de Scala for the Impatient, parte 10


Modificar Map

Para poder modificar datos de un map debemos utilizar un mapa mutable. Y lo podemos hacer de la siguiente manera:

scores("Bob") = 10
// Actualiza el valor de la key “Bob” asumiendo que esta existe.
scores("Fred") = 7
//Agrega una nueva key y valor (asumiendo que es un map mutable)

Alternativamente podemos utilizar el operador += para modificar y agregar valores de forma masiva:
scores += ("Bob" -> 10, "Fred" -> 7)
Podemos remover una key con el operador -=
scores -= "Alice"

No se puede modificar mapas inmutables (de hay lo de inmutable) pero podemos crear nuevos mapas con diferentes valores:

val newScores = scores + ("Bob" -> 10, "Fred" -> 7) // Nuevo mapa con valores modificados

Ahora obtenemos un nuevo mapa llamado newScore con el valor de “Bob” modificado y “Fred” agregado.

De la misma manera podemos utilizar este operador para un mapa mutable:

var scores = ...
scores = scores + ("Bob" -> 10, "Fred" -> 7)

De igual forma podemos remover valores con el - :
scores = scores – "Alice"

Se podría pensar que es ineficiente construir nuevos mapas por operador, pero esto no es así. Dado que los mapas antiguos y nuevos comparten la mayor parte de su estructura. (Esto es posible porque son inmutables.)

Iterando sobre los mapas

Iterar sobre todos los pares clave / valor de un mapa es fácil, podemos utilizar el bucle for:
for ((k, v) <- map) process k and v

La magia aquí esta en el uso de pattern matching usado en el bloque for. Luego vamos a hablar de pattern matching, no se preocupen. De este modo obtenemos la clave y el valor en cada iteración.

Si necesitamos solamente iterar por Key, podemos utilizar el método KeySet de java o values para iterar por valor:

scores.keySet // retorna un set con las claves:  Set("Bob", "Cindy", "Fred", "Alice")
for (v <- scores.values) println(v) // Imprime los valores.

Por supuesto podemos utilizar esta técnicas con lo antes aprendido, si por ejemplo deseamos retornar un mapa donde su valor sea la clave del anterior:

for ((k, v) <- map) yield (v, k)

martes, 21 de febrero de 2017

Gogland, la ide para Go


Efectivamente Go se viene con todo y la gente de Jetbrains (que es muy inteligente) hizo una ide para este lenguaje.

La IDE es gratuita, la acabo de bajar. El nuevo entorno solamente puede probarse a través de un programa de acceso temprano (early access program – EAP), pero esto es por el momento. Más adelante debería ser un producto terminado, dependiendo de como se reciba el producto.

Gogland ofrece lo mismo que un IDE de Jetbrains por lo tanto contamos con : análisis del código, navegación rápida, análisis de errores, formateo, refactoreo, debug, etc.

Dejo link: https://www.jetbrains.com/go/

Try Elixir

Codeschool nos regala otro curto al modo de try como ya lo conocemos, sin más:

Try Elixir

Begin learning the basics of Elixir and take your first steps into the world of functional programming.
 Coming Soon - We'll remind you.

Course Overview

  1. Level 1 on Try Elixir

    LEVEL 1 FREE LEVEL 1 Video | 4 Challenges
    Modules & Functions

    Get started in the world of functional programming with Elixir by learning how to work with named functions.
  2. Level 2 on Try Elixir

    LEVEL 2 FREE LEVEL 1 Video | 2 Challenges
    The Pipe Operator

    Learn how to refactor nested function calls into an easier syntax, using the pipe operator.
  3. Level 3 on Try Elixir

    LEVEL 3 FREE LEVEL 1 Video | 4 Challenges
    Pattern Matching

    Explore how pattern matching works and how we can use it to remove if statements from our programs.
Try Elixir
COMPLETE THESE LEVELS TO UNLOCK

Course Completion Badge

Begin learning the basics of Elixir and take your first steps into the world of functional programming.

Supplemental Learning



    Dejo link:
    https://www.codeschool.com/courses/try-elixir?utm_source=facebook&utm_medium=social

    viernes, 17 de febrero de 2017

    Un resumen de Scala for the Impatient, parte 9

    Interoperabilidad con Java

    Los arreglos de scala fueron implementados como los arreglos de java por lo tanto podemos pasar de uno a otro.

    Si necesitamos llamar a un método java que retorna un java.util.List podemos hacerlo y utilizar java.util.ArrayList. Pero es mejor utilizar colecciones de scala, por lo tanto podemos utilizar una convercion implicita, importando scala.collection.JavaConversions luego podemos utilizar ArrayBuffer de scala.

    Por ejemplo java.lang.ProcessBuilder necesita una lista de parametros de tipo List<String> por lo tanto podemos hacer lo siguiente:

    import scala.collection.JavaConversions.bufferAsJavaList
    import scala.collection.mutable.ArrayBuffer

    val command = ArrayBuffer("ls", "-al", "/home/cay")
    val pb = new ProcessBuilder(command) // Scala a Java

    De igual manera podemos pasar de una lista de Java a un buffer de Scala:

    import scala.collection.JavaConversions.asScalaBuffer
    import scala.collection.mutable.Buffer

    val cmd : Buffer[String] = pb.command() // Java to Scala

    Construyendo un mapa

    Empecemos por el principio un mapa es una estructura que permite acceder a elementos por medio de una llave o key. Por lo tanto debemos insertar tanto el valor como la key.

    Podemos crear un mapa de forma declarativa:

    val scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)

    De esta forma se creea un mapa inmutable. Si esperamos hacer un map mutable debemos hacerlo de la siguiente manera:

    val scores = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)

    Si necesitamos iniciar un mapa vacio, debemos indicar el tipo:

    val scores = new scala.collection.mutable.HashMap[String, Int]

    En Scala un map no es mas que una colección de pares. El operador -> crea los pares. Por ejemplo:

    "Alice" -> 10 es ("Alice", 10)

    Por lo tanto podemos definir un mapa de la siguiente manera:

    val scores = Map(("Alice", 10), ("Bob", 3), ("Cindy", 8))
    El operador -> es un poco amigable que los paréntesis.

    Acceder a los valores del mapa: 

    En Scala podemos acceder a los valores con los parentesis:

    val bobsScore = scores("Bob") // Como scores.get("Bob") en Java

    Si el mapa no contiene el valor para una key, se lanza una excepción.

    val bobsScore = if (scores.contains("Bob")) scores("Bob") else 0

    Podemos utilizar la función getOrElse para hacer algo similar:

    val bobsScore = scores.getOrElse("Bob", 0)

    Por ultimo podemos acceder al elemento por medio del método get que retorna un Option objeto que puede ser Some o None. Que vamos a explicarlo más adelante.

    lunes, 13 de febrero de 2017

    Ganar ventaja competitiva con MySQL

    Me llego un mail por demás interesante sobre mysql. Oracle regala un paper que nos indica como hacer una diferencia comercial.

    Sin más les dejo el mail:

    View this message in a Web browser
    Guide to MySQL as an Embedded Database
    White Paper
    A Guide for SaaS Vendors: Gaining Competitive Advantage with MySQL
    Guide to MySQL as an Embedded Database
    Access Resource Kitcta-arrow
    Proven Reliability 

    Relied on by many of the world’s largest software vendors as well as small SaaS startups to power their solutions and help them
    • Get to market and into production faster
    • Gain competitive advantage
    • At lower total cost
    Access Resource Kit text-cta-arrow
    Stay Connected
    FacebookLinkedinTwitterYoutubeGooglePlus
    Terms of Use and Privacy | Subscriptions | Un‌subscribe | Contact Us

    domingo, 12 de febrero de 2017

    Como aprender smalltalk puede hacerte mejor desarrollador


    Me encontre con un articulo muy bueno, que asegura que si aprendes smalltalk vas a mejorar como desarrollador. Me gusto esta hipotesis...

    Smalltalk es ampliamente percibido como un viejo lenguaje moribundo, una antigüedad de una época pasada. Nada mas lejos de la verdad.

    Smalltalk sigue siendo muy relevante. Es un excelente lenguaje para la enseñanza de programación a personas que no tienen antecedentes técnicos. Es un lenguaje de prototipado superlativo para las startups. Es un lenguaje utilizado por las empresas grandes y pequeños en todo el mundo. Hay buenas razones para considerar el uso de Smalltalk moderno hoy en día, ya que ha cambiado mucho en los últimos años.

    No es necesario que use Smalltalk en la producción, pero intente codificar algo en Smalltalk y va a ver cómo se siente. Debe sentirse familiar, porque la implementación de Smalltalk del paradigma orientado a objetos (OO) es tan excelente que ha influido en toda una generación de lenguajes OO, como Objective-C, Python, Ruby, CLOS, PHP 5, Perl 6, Erlang , Groovy, Scala, Dart, Swift, y así sucesivamente.

    Al aprender Smalltalk, comprenderá cómo todas esas características útiles en los idiomas OO actuales llegaron a ser. Aprender Smalltalk también podría darle una gran ventaja en las habilidades de programación entre sus compañeros, y podría ser una gran herramienta para la enseñanza de la programación para los principiantes.

    Que nos ha dejado smalltalk?
    • Smalltalk introdujo el mundo en la máquina virtual de lenguaje (o VM), que permite que el software sea independiente de la plataforma. Esta es la misma tecnología que sustenta Java (JVM) y .NET, así como Android (Dalvik).
    • Smalltalk también fue pionero en la compilación JIT (just-in-time), una técnica para mejorar drásticamente el rendimiento de software de bytecode como Java.
    • Desde Smalltalk surgió el primer IDE moderno (entorno de desarrollo integrado), que incluía un editor de texto, un navegador de sistema o clase, un inspector de objetos o propiedades y un depurador. Esto llevó a los muchos IDE que los desarrolladores favorecen hoy en día, como Visual Studio, Xcode e IntelliJ IDEA. P
    • Desde el principio, Smalltalk tenia clausuras, que son funciones de primera clase. En esencia, una clausura es una función que puede ser asignada a una variables. Esto puede ayudarle a escribir código mucho más compacto y legible. Las clausuras están encontrando su camino en muchos lenguajes, como Java, C # y PHP.
    • Smalltalk fue el padre de la depuración como la conocemos.
    • Smalltalk presentó MVC (Model-View-Controller) al mundo. MVC es un patrón de arquitectura de software para implementar interfaces de usuario. Es popular entre las aplicaciones GUI de escritorio y las aplicaciones web. En estos días, es la arquitectura que la mayoría de los desarrolladores web aprender primero.
    • En gran medida, Smalltalk es responsable de darnos el desarrollo basado en pruebas (o TDD) y la programación extrema (o XP), que son ambos muy influyentes en las prácticas ágiles estándar actuales.
    • Smalltalk fue pionera en el desarrollo de bases de objetos. El mejor ejemplo de un producto de base de objetos es GemStone / S, que se adapta perfectamente a sistemas distribuidos escalables, de alto rendimiento y multitotal.
    • Smalltalk nos dio el primer navegador de refactorización. Por supuesto, refactorización de apoyo se puede encontrar en la mayoría de los IDEs de hoy.
    • Smalltalk fue instrumento en el desarrollo de la interfaz gráfica de usuario (GUI) y la interfaz de usuario "lo que ves es lo que obtienes" (WYSIWYG).
    Que más decir son varias razones. 

    Dejo link: 

    Machine Learning with Spark

    La editorial packt nos regala el libro "Machine Learning with Spark" para podernos interiorizar de la tecnología Machine Learning y Spark.

    Sin más dejo el link:
    https://www.packtpub.com/packt/offers/free-learning/?utm_source=googlep-dp&utm_medium=social-dp&utm_campaign=FL-dp

    lunes, 6 de febrero de 2017

    Introducción a R


    La gente de Attune nos regala un nuvo libro en este caso sobre R. R es amplamente utilizado en el plano de la estadistica por las facilidades que presenta.

    Dejo el link:
    http://www.attuneww.com/publications/getting-started-with-r.html

    domingo, 5 de febrero de 2017

    devfreebooks


    Queres libros de programación, frameworks, diseño, etc. libres y gratuitos? Bueno pasa por devfreebooks, un sitio muy recomendable donde podes encontrar libros de diferentes lenguajes como diferente tecnologías.

    Sin más dejo el link: https://devfreebooks.github.io/

    viernes, 3 de febrero de 2017

    Un resumen de Scala for the Impatient, parte 8


    Arrays de longitud fija

    Si necesitamos usar un array de longitud fija, puede utilizar una estructura Array, veamos un ejemplo:

    val nums = new Array[Int](10)
    // Se crea un arreglo de 10 elementos de tipo entero inicializados en 0

    val a = new Array[String](10)
    // un arreglo de string inicializados en null

    val s = Array("Hello", "World")
    // Un arreglo de 2 strings

    s(0) = "Goodbye"
    // Array("Goodbye", "World")
    // Se puede usar () en vez de []

    Arreglos de longitud variable

    Java tiene ArrayList y C++ el vector de la STL, equivalente en scala es el ArrayBuffer.

    import scala.collection.mutable.ArrayBuffer

    val b = ArrayBuffer[Int]()
    // o new ArrayBuffer[Int]
    // ahora tenemos un array de 0 elementos (vacio)

    b += 1
    // ArrayBuffer(1)
    // Agregamos un elemento al final con +=

    b += (1, 2, 3, 5)
    // ArrayBuffer(1, 1, 2, 3, 5)
    // agregamos multiples elementos al final con += y los elementos entre parentesis

    b ++= Array(8, 13, 21)
    // ArrayBuffer(1, 1, 2, 3, 5, 8, 13, 21)
    // Se puede agregar colecciones con el operador ++=

    b.trimEnd(5)
    // ArrayBuffer(1, 1, 2)
    // remueve los últimos 5 elementos del final

    Se pueden insertar elementos en cualquier parte del vector con insert:

    b.insert(2, 6)
    // ArrayBuffer(1, 1, 6, 2)
    // inserta en la posición 3 es decir en el índice 2 (recuerden que el índice comienza en 0)

    b.insert(2, 7, 8, 9)
    // ArrayBuffer(1, 1, 7, 8, 9, 6, 2)
    // se pueden insertar multiples elementos

    b.remove(2)
    // ArrayBuffer(1, 1, 8, 9, 6, 2)

    b.remove(2, 3)
    // ArrayBuffer(1, 1, 2)
    // El segundo parámetro nos indica cuantos elementos borrar.

    En ciertas ocasiones debemos utilizar un array y no un ArrayBuffer por lo que podemos convertir estos tipos con las funciones toArray y toBuffer

    En c++ y Java existen muchas diferencias entre la sintaxis de un array y una lista o vector dinámico,   en scala esto es mucho más uniforme.

    Por ejemplo aquí podemos ver como recorrer un Array o un ArrayBuffer:

     for (i <- 0 until a.length)
       println(i + ": " + a(i))

    La variable i va ir desde 0 hasta a.length – 1

    until es un método de RichInt que retorna el rango desde el elemento hasta el parámetro -1 (es decir sin incluir este elemento)

    0 until 10
    // Range(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

    Podemos llamar a este método con 0.until(10)

    Por lo tanto podemos deducir que el for trabaja de la siguiente manera:

    for (i <- rango)

    y por cada iteración i toma un valor del rango. until guarda más secretos, podemos hacer rangos con  saltos:

    0 until (a.length, 2)
    // Range(0, 2, 4, ...)

    o podemos hacer rangos y luego darlos vuelta:

    (0 until a.length).reverse
    // Range(..., 2, 1, 0)

    Si no necesitamos índices para recorrer el arreglo, solo podemos asignar los elementos de la colección:

    for (elem <- a)
    println(elem)

    Como se puede ver es similar a iterar con un rango.

    Transformar un arreglo

    Podemos transformar arreglos de forma similar que Java o C++ pero tenemos una herramienta mucho más simple. Podemos transformar los arreglos por comprensión:

    val a = Array(2, 3, 5, 7, 11)
    val result = for (elem <- a) yield 2 * elem
    // result is Array(4, 6, 10, 14, 22

    yield es una palabra reservada, este operador permite retornar otro arreglo con los elementos modificados según la operación que se aplique. En el ejemplo result contiene el arreglo resultado.

    También podemos filtrar con el for y luego aplicar la transformación:

    for (elem <- a if a % 2 == 0) yield 2 * elem

    Esto no afecta la colección original.
    Noten que también podríamos usar funciones de map que son más potentes:

    a.filter(_ % 2 == 0).map(2 * _)

    o también

    a filter { _ % 2 == 0 } map { 2 * _ }

    Algoritmos comunes 

    Similar a la STL de c++ o a las clases Collections y Arrays de java. Scala cuenta con métodos que nos permiten acumular o ordenar:

     Array(1, 7, 2, 9).sum
    // 19
    // Esto también funciona con ArrayBuffer

    Note que sum funciona para valores de tipo numéricos, que se pueden sumar. De igual manera min y max funciona para valores que se pueden comparar.

    ArrayBuffer("Mary", "had", "a", "little", "lamb").max
    // "little"

    El método para ordenar retorna una colección ordenada, sin modificar la colección original:

    val b = ArrayBuffer(1, 7, 2, 9)
    val bSorted = b.sorted(_ < _)
    // b is unchanged; bSorted is ArrayBuffer(1, 2, 7, 9)

    Para los arreglos podemos utilizar mkString con el cual podemos hacer strings a partir de nuestros arreglos:

    a.mkString(" and ")
    // "1 and 2 and 7 and 9"
    a.mkString("<", ",", ">")
    // "<1,2,7,9>"

    Arreglos multidimensionales.

    Similar a Java, scala implementa arreglos multidimensionales como arreglos de arreglos. Por ejemplo:

    val matrix = Array.ofDim[Double](3, 4)

    y para acceder a los valores es necesario poner paracentesis con el índice de la fila y luego paréntesis con el índice de la columna.

    matrix(row)(column) = 42