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: 

https://techbeacon.com/how-learning-smalltalk-can-make-you-better-developer

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

Framework javascript más populares en 2017

Les dejo una genial infrografia:

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

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/

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

Functional Programming vs. Imperative Programming en c#

Hace mucho que no posteo sobre el amigo C# y la verdad es que estoy algo oxidado... Pero me intereso este articulo y se merecia un post.

El paradigma de programación funcional fue creado explícitamente para la resolución de problemas con enfoque matemático puro. La programación funcional es una forma de programación declarativa. En cambio, la mayoría de los lenguajes convencionales, incluidos los lenguajes de programación orientada a objetos (OOP) como C #, Visual Basic, C ++ y Java, fueron diseñados principalmente para soportar la programación imperativa (de procedimiento).

En la programación orientada a objetos tradicional (OOP), la mayoría de los desarrolladores están acostumbrados a la programación en el estilo imperativo / procedimental. Para cambiar al desarrollo en un estilo funcional puro, tienen que hacer una transición en su pensamiento y su acercamiento al desarrollo.

Para resolver problemas, los desarrolladores de OOP diseñan jerarquías de clases, se enfocan en la encapsulación apropiada y piensan en términos de contratos de clases. El comportamiento y el estado de los tipos de objetos son primordiales, y se proporcionan características del lenguaje, como clases, interfaces, herencia y polimorfismo, para abordar estas preocupaciones.
Por el contrario, la programación funcional aborda los problemas computacionales como un ejercicio de evaluación de las transformaciones funcionales puras de las colecciones de datos. La programación funcional evita los datos de estado y mutables, y en su lugar enfatiza la aplicación de funciones.

Afortunadamente, C # no requiere el salto completo a la programación funcional, ya que soporta los enfoques de programación tanto imperativos como funcionales. Un desarrollador puede elegir qué enfoque es el más apropiado para un escenario en particular. De hecho, los programas a menudo combinan ambos enfoques.

Dejo link:
https://msdn.microsoft.com/en-us/library/mt693186.aspx

Que lenguaje de programación fue el que más popular en el 2016?

Según el índice TIOPE : Go!

Si el lenguaje de google sigue creciendo y se lleva la distinción del lenguaje más popular.

La pagina de tiope dice lo siguiente (más o menos) :

TIOBE recompensa el lenguaje de programación que ha ganado la mayor popularidad en un año con el premio de lenguaje de programación del año. Sin prácticamente ninguna competencia Go ha ganado el premio para el año 2016. El lenguaje google Go ganó con un  2,16% en un año. Seguido de Dart (+ 0.95%) y Perl (+ 0.91%). Los principales impulsores del éxito de Go son su facilidad de aprendizaje y naturaleza pragmática. No se trata de conceptos teóricos como la herencia virtual y las mónadas, sino la experiencia práctica. Aparte de eso, Go incorpora soporte para la programación en paralelo. por lo que cada vez más clientes de nuestra empresa TIOBE están adoptando Go en un entorno industrial. Es un buen indicador.

Personalmente opino que no es bueno que un lenguaje triunfe solo por pragmático, claramente en los conceptos podemos desarrollarnos. Pero solo una opinion personal.

Bueno que más decir, felicitaciones Go!

Dejo link: http://www.tiobe.com/tiobe-index/?imm_mid=0ec6d0&cmp=em-prog-na-na-newsltr_20170121

Scala by the pictures

Quiero compartir una pagina que esta muy buena, y se pueden ver buenas infografias de Scala.

Dejo link:
http://sciabarra.com/book/

Libro Aprendiendo Ruby on Rails 5 - Capítulo 6 disponible

Me llego este mail y lo comparto para todos los que quieran aprender Ruby:

Libro Aprendiendo Ruby on Rails 5 View this email in your browser

Capítulo 6 "Actualizando nuestra aplicación a Ruby on Rails 5". El capítulo 6 ya está disponible y viene con un cambio importante, el enfoque del libro ya no es Ruby on Rails 4.2, en su lugar es Ruby on Rails 5, la versión más reciente de este marco de trabajo. A quienes hayan comprado el libro, en las próximas horas les llegará un correo electrónico con las instrucciones de como descargar la actualización. El capítulo habla de como migrar una aplicación de Ruby on Rails 4.2 a 5, nos lleva de la mano por todo el proceso hasta completar la actualización de manera exitosa. Como siempre el capítulo está disponible en formato de eBook para Kindle, ePub y PDF. Si aún no han comprado el libro y les interesa tenerlo, pueden comprarlo el libro aquí. Para conocer del contenido de éste capítulo visita http://www.railsenespanol.co/capitulos/capitulo5. Para tener acceso a los capítulos 1 y 2, sólo en necesario navegar al sitio y en la lista de temarios aparece el link para cada capítulo. http://www.railsenespanol.co/.   Acceso al foro del libro. Quienes compraron el libro ya para el día de hoy recibienron via correo electrónico la invitación a Slack, donde podrán comentar y hacer observaciones sobre el contenido del libro. Early Access del libro. Los capítulos 1 y 2 están disponibles en línea de forma gratuita, pero ya es posible realizar la compra del libro en modo Early Access, es decir pre-pagar el libro con un precio especial y tener acceso a los siguientes capítulos conforme se va liberando. En el modo Early Access también tendrás acceso al libro en los formatos PDF, Kindle y ePub para iPad, iPhone y Mac. El costo del libro es $15USD. Si quieres ayudar con el desarrollo del libro, puedes comprarlo en aquí.   Comprar el libro Share Tweet +1 Share Forward

Que lenguajes de programación son usados por cada compañía?

Yo creo que esto ya lo publique, pero bueno, el publico se renueva. 

Dejo el link: http://www.improgrammer.net/the-programming-language-used-by-the-company/

Un resumen de Scala for the Impatient, parte 7

Procedimientos. 

Los procedimientos en Scala retornan el tipo Unit y tienen una especial notación sin el =

def box(s : String) { // Look carefully: no =
  val border = "-" * s.length + "--\n"
  println(border + "|" + s + "|\n" + border)
}

Algunas personas no les gusta esta notación por lo que eligen utilizar la misma que las funciones:

def box(s : String): Unit = {
...
}

Lazy Values

Cuando un valor es declarado como lazy el calculo de este valor se realiza cuando se necesita, no antes:

lazy val words = scala.io.Source.fromFile("/usr/share/dict/words").mkString

De esta manera, si words no es utilizado el archivo nunca se abrirá.

Lazy values es útil para retrasar declaraciones de inicialización costosas. También pueden solucionar otros problemas de inicialización, como las dependencias circulares. Además, son esenciales para desarrollar estructuras de datos perezosas como Streams.

val words = scala.io.Source.fromFile("/usr/share/dict/words").mkString
// Se evalúa en el momento que es definido
lazy val words = scala.io.Source.fromFile("/usr/share/dict/words").mkString
// Se evalúa en el momento que es usado
def words = scala.io.Source.fromFile("/usr/share/dict/words").mkString
// Se evalúa cada vez que es usado

Exceptions

Las excepciones funcionan igual que C++ o Java. Cuando se lanza una excepción, por ejemplo:

throw new IllegalArgumentException("x should not be negative")

Se anula la ejecución y el sistema de ejecución busca un manejador de excepciones que puede manejar la excepción IllegalArgumentException. Si esta es manejada se reanuda la ejecución donde es manejado, si no existe un manejador, el programa finaliza. Igual a java.

Como en Java, las excepciones que se lanzan deben ser una subclase de java.lang.Throwable. Sin embargo, a diferencia de Java, Scala no tiene excepciones "verificadas o chequeadas" es decir que nunca se debe declarar una función o un método que lanza una excepción.

Una expresión throw retornan el tipo especial Nothing. Esto es útil en las expresiones if / else. Si una rama tiene el tipo Nothing, el tipo de la expresión if / else es el tipo de la otra rama. Por ejemplo, considere:

if (x >= 0) { sqrt(x)
} else throw new IllegalArgumentException("x should not be negative")

Esta expresión retornara Double, dado que el else retorna Nothing.

La expresión try puede utilizar pattern matching:


try {
process(new URL("http://horstmann.com/fred-tiny.gif"))
} catch {
case _: MalformedURLException => println("Bad URL: " + url)
case ex: IOException => ex.printStackTrace()
}

Cuando no necesitamos las variables podemos utilizar el _ (guión bajo)

La instrucción try / finally le permite disponer de un recurso independientemente de que se haya producido o no una excepción. Por ejemplo:

var in = new URL("http://horstmann.com/fred.gif").openStream()
try {
process(in)
} finally {
in.close()
}

La cláusula finally se ejecuta independientemente de si la función de proceso lanza una excepción. La variable in siempre cerrara el recurso.

Este código es un poco sutil, y plantea varios problemas.

• ¿Qué pasa si el constructor de URL o el método openStream lanza una excepción? Entonces el bloque try nunca se ingresa, y tampoco es la cláusula finally. Por lo tanto nunca se inicializara. 
• ¿Por qué no es val in = nueva URL (...). OpenStream () dentro del bloque try? Entonces el alcance de en no se extendería a la cláusula final.
• ¿Qué pasa si in.close () lanza una excepción? Entonces esa excepción es expulsada de la declaración, reemplazando cualquier anterior. (Esto es igual que en Java, y no es muy agradable.) Idealmente, la antigua excepción permanecería unida a la nueva.

Note que try / catch y try / finally tienen objetivos complementarios. La sentencia try / catch maneja las excepciones, y la sentencia try / finally toma alguna acción (normalmente cleanup) cuando no se maneja una excepción. Es posible combinarlas en una sola instrucción try / catch / finally:

try { ... } catch { ... } finally { ... }

Codeschool lanza un nuevo curso de PHP

Codeschool viene con todo y cada vez más amplia sus tecnologías, ahora nos ofrece un curso de PHP:

Deepen your PHP knowledge and start working with forms, validation, and custom libraries when you play Close Encounters With PHP. View the Course What You'll Learn Level 1: Requests & Forms Explore and begin working with HTTP POST and GET requests.          Level 2: Includes & Requires Learn how to include and/or require files from other parts of the filesystem. Level 3: Validation & Security Start creating your own validation and functions.                                  Level 4: Composer & Autoloading Learn how to refactor with PSR-1 and install and use Composer.          Level 5: Validation With Respect Discover and use our new package, respect/validation.

Have questions or need assistance? SUPPORT FAQ © 2016 Code School LLC. Crafted lovingly in Orlando, Florida. Code School 618 E South Street Suite 620 Orlando, FL 32801 USA Edit your email settings     Unsubscribe

Los Programadores Andan Diciendo

Me reí muchísimo con este grupo en facebook, por lo que lo comparto:

https://www.facebook.com/ProgramadoresAndanDiciendo/?pnref=story

Un resumen de Scala for the Impatient, parte 6

Funciones. 

Scala tiene funciones además de métodos. La diferencia es que las funciones no pertenecen a ningún objeto.
Para definir una función solo es necesario, nombre, parámetros y el cuerpo de la función:

def abs(x: Double) = if (x >= 0) x else -x

No es necesario definir el tipo, dado que el compilador lo infiere. En el caso que no pueda inferirlo como funciones recursivas, se le debe indicar.

Si la función debe hacer varias cosas se puede utilizar las llaves:

def fac(n : Int) = {
    var r = 1
    for (i <- 1 to n) r = r * i
     r
}

La función retorna lo ultimo que se ejecuta y no es necesario la palabra return.

Se pueden utilizar valores por defecto para las funciones:

def decorate(str: String, left: String = "[", right: String = "]") =
         left + str + right

Si llamamos a decorate("Hello") , el resultado va a ser :  "[Hello]"
Si llamamos a decorate("Hello", ">>>[") el resultado va a ser : ">>>[Hello]", pero, ¿como podemos llamar a la función con un parámetro para rigth y el default para left? con los parámetros nombrados:

decorate("Hello", right = "]<<<") // Calls decorate("Hello", "[", "]<<<")

Podemos nombrar todos los parámetros:

decorate(left = "<<<", str = "Hello", right = ">>>")

El resultado es "<<<Hello>>>" . Note que el orden de los parámetros no eran iguales que como fueron definidos.

Algunas veces es necesario implementar funciones con un numero variable de parametros, esto se hace con el * :

def sum(args: Int*) = {
    var result = 0
    for (arg <- args) result += arg
    result
}

Y esto se puede llamar de la siguiente manera:

val s = sum(1, 4, 9, 16, 25)
La función recibe un parámetro de tipo Seq pero no podemos pasar una sequencia desde una función por ejemplo esto retornara error:

val s = sum(1 to 5) // Error

Si la función es llamada con un solo argumento este debe ser entero y no rango de enteros, para solucionar este problema se debe agregar _* :

val s = sum(1 to 5: _*) // Consider 1 to 5 as an argument sequence

Si necesitamos llamar a una función recursiva podemos utilizar el mismo artilugio:

def sum(args: Int*) : Int = {
   if (args.length == 0) 0
   else args.head + recursiveSum(args.tail : _*)
}