Microsoft se une a la Linux Foundation

Ya hemos hablado de la iniciativa de microsoft de participar en Linux Foundation. Pero ahora es real. Sí, Microsoft se une a Linux Foundation. Lo hace, además, como miembro de platino, por lo que compartirá el lugar más privilegiado de la tabla con otras compañías como Cisco, Fujitsu, HPE, Huawei, IBM, Intel o Samsung.

Dejo link: https://www.linuxfoundation.org/members/corporate

Dictionary en smalltalk

El Dictionary (Diccionario) es una colección que puede verse desde 2 puntos de vista:

Como un Set de asociaciones clave->valor

Como un contenedor donde los elementos son nombrados desde el exterior, donde el nombre puede ser cualquier objeto que responda al mensaje #=.

Ejemplos:

"instanciar, y llenar, un diccionario"
| diccionario |

diccionario := Dictionary new.

diccionario at: 'hoy' put: Date today.
diccionario at: 'ahora' put: Time now.
diccionario at: false put: 'es false'.

"algunas formas de acceder al diccionario"
diccionario at: 'hoy'.
diccionario at: 'mañana' ifAbsent:[nil].
diccionario at: 'mañana'.
diccionario at: 'mañana' ifAbsentPut:[Date tomorrow].
diccionario at: 'mañana'.

"otras formas de acceso"
diccionario keys.
diccionario values.

"algunas iteraciones"
Transcript clear.
Transcript cr; show: '#do:'; cr.
diccionario do: [:each |
   Transcript show: ' ' , each asString; cr.
].

Transcript cr; show: '#associationsDo:'; cr.
diccionario associationsDo: [:each |
   Transcript show: ' ' , each asString; cr.
].

Transcript cr; show: '#keysAndValuesDo:'; cr.
diccionario keysAndValuesDo:[:eachKey :eachValue |
   Transcript show: ' ' , eachKey asString , ' - ' , eachValue asString; cr.
].

Estudiar Smalltalk

Sin duda lo más importante para aprender Smalltalk es meter mano en un Smalltalk.  No vale de nada leer cientos de libros si no nos metemos de lleno en un ambiente de Smalltalk y comenzamos a hacer cosas.

Pero también es cierto que la experiencia puede ser más fácil si logramos percibir algo de la filosofía del desarrollo con Smalltalk desde algunos libros. Por lo tanto quiero recomendarles:

Libros

• Smalltalk-80 - The Language: En este libro se puede entender, de personas que participaron en el desarrollo de Smalltalk, la filosofía del lenguaje y las motivaciones que lo hicieron posible.
• Smalltalk-80 - Bits of  History, Words of Advice: Este libro me impactó por lo actual de los comentarios hechos por personas que probaron Smalltalk a principios de los años 80.
• Smalltalk Best Practice Patterns: Este libro me enseño que una de las cosas más importantes, para ser un buen programador Smalltalk, es prestar muchísima atención a la claridad del código.
• Smalltalk with Style: Este libro me mostró la mayoría de las convenciones que se utilizan a la hora de escribir código Smalltalk.
• Design Patterns - Elements of Reusable Object Oriented Software: No es posible decir hoy en día que se sabe programar con objetos si no se ha leído este libro. Este libro es el culpable de que hoy esté escribiendo un libro de Smalltalk y no uno de Java o .NET.  Me enteré de la existencia de Smalltalk, y de su impacto sobre la tecnología de objetos, a través de las explicaciones de algunos patrones.  Este es el libro que despertó mi curiosidad por aprender Smalltalk.
• The Dessign Patterns Smalltalk Companion: Este libro me enseñó mucho Smalltalk por comparación con la implementación de los patrones en el libro anterior.

Papers o artículos

• Design Principles Behind Smalltalk: Excelente descripción de las motivaciones que rigen el desarrollo del proyecto Smalltalk.  Parece ciencia ficción si consideramos que la nota fue publicada en la revista Byte de agosto de 1981.
• Personal Dynamic Media: Excelente explicación de las motivaciones detrás del desarrollo de Smalltalk escrita por Alan Kay en el año 1976.
• The Early History of Smalltalk: Esta es una historia de Smalltalk, escrita por Alan Kay, en el año 1993 (antes de que comenzara el proyecto Squeak allá por el 1995) donde cuenta de donde vienen las ideas principales.  Termina con una frase que también me marcó especialmente: “¿Donde están los Dan (Ingalls) y las Adele (Goldberg) de los 80s y los 90s que nos lleven al próximo nivel de desarrollo?”.

Test Driven Development

El objetivo de todo programador debería ser el de generar Código Limpio que Funciona.

Existen numerosas razones para escribir Código Limpio que Funciona (CLQF), algunas de ellas son:

• Generar CLQF es una forma predecible de desarrollar. Se puede saber cuando se termina el desarrollo y no nos preocupamos por un largo ciclo de depuración.
• El CLQF nos da la oportunidad de aprender todas las lecciones que el código tiene que decirnos.
• El CLQF brinda mejores oportunidades a los usuarios de nuestro software.
• El CLQF permite que nosotros confiemos en nuestros compañeros y que ellos confíen en nosotros.
• Cuando escribimos CLQF, nos sentimos mejor con nosotros mismos.

Hay muchas fuerzas que nos dificultan escribir CLQF, entonces ¿cómo podemos generar CLQF?.

Esta metodología (Test Driven Development - TDD) consiste en hacer que los tests automáticos sean los que rigen el desarrollo.  Para eso seguimos la siguiente reglas:
Escribir nuevo código sólo si tenemos un test automático que falla.
Eliminar la duplicación.

Aplicar esas 2 reglas imprimen el siguiente ritmo al proceso de desarrollo:
Rojo: Escribir un test que falle.
Verde: Hacer que el test funcione lo más rápidamente posible.  Podemos cometer cuantos pecados queramos en esta etapa ya que el objetivo es salirse del rojo cuanto antes.

Refactorizar: Eliminar toda la duplicación creada en el paso anterior.

Dejo link:
http://es.wikipedia.org/wiki/Tdd
http://en.wikipedia.org/wiki/Test_driven_development

Libros de programación gratuitos

La gente de o'reilly están regalando unos buenos libros. Tenemos diferentes temas java, python, open source, reactive, microservice, etc. 

Solo se debe ingresar el nombre y el email. 

Son muy buenos!!! 

Dejo link: http://www.oreilly.com/programming/free/

Canales de youtube para aprender a programar

Nunca use un canal para aprender programación y la verdad me arrepiento, les paso un grupo de canales que están muy buenos.

Dejo link:
https://www.youtube.com/channel/UC9fAeSPVw7mAAbexCS7gPqw
https://www.youtube.com/channel/UCQufRmIMRTLdRxTsXCh4-5w

Estados Unidos legalizo el hackeo de autos y televisores inteligentes

Leyendo clarin, me encontré con una grata noticia. Porque grata? Porque si es legal que pueda ver el codigo de mi auto, las empresas van a tener que compartirlo. Esto es un gran paso.

Si bien esto debería ser así, no lo es. Alguien puede vender autos que transmitan la posición del auto y sin informarnos esto,  si no se puede ver el código nunca me enteraré.

Si lo llevamos a otros ámbitos, podríamos comprar un auto y no poder saber como funciona, de esta forma si gasta más combustible solo para beneficiar a las petroleras. No me enteraría, ni podría enterarme.

Por esta razón es una buena noticia.

Dejo el link:
http://next.clarin.com/Unidos-legalizo-hackeo-televisores-inteligentes_0_1681031923.html

Scala on Android

Si, se pueden desarrollar aplicaciones en Scala con Android. Y quiero compartir un link el cual tiene toda la información de como empezar.



Dejo link: http://macroid.github.io/ScalaOnAndroid.html

Generics en Java

Creo que este tema esta más que entendido por los seguidores, pero siempre hay gente nueva dispuesta a aprender.

Cualquier lenguaje de tipado estático tiene un problema y es que dada una estructura de datos generica, debemos programarla n veces como n sea el tipo de datos que queramos usarla.

Una posible solución es tipar esta estructura a object, esto trae con sigo ciertos problemas.

• Se pierde la seguridad por tipo.
• Debemos castear al tipo de la estructura cada vez que consultemos un elemento:

List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);

A partir de java 5 se introduce el concepto de clases genéricas. Permiten utilizar y programar estructuras genéricas, las cuales  se les indica el tipo:

List<String> list = new ArrayList<String>();
list.add("hello");
String s = list.get(0);   // no cast

Entre las ventajas podemos nombrar:

• Chequeo de tipos
• Se elimina la necesidad de casteos.
• Posibilidades  de utilizar y programar algoritmos y estructuras genéricas 
• Es muy utilizado en Framework de colecciones de java. 

Podemos generar clases genericas: 

public class Box<T> {

    // T stands for "Type"

    private T t;

    public void set(T t) { this.t = t; }

    public T get() { return t; }

}

Donde T es el tipo de nuestra clase genérica. Si queremos utilizar esta clase para un tipo determinado:

Box<Integer> integerBox = new Box<Integer>();

integerBox.set(45);

Integer nro = integerBox.get();

Y con el operador diamante: 

Box<Integer> integerBox = new Box<>();

integerBox.set(45);

Integer nro = integerBox.get();

Como ven el operador diamante, no es más que no decirle el tipo cuando instancio la clase, porque el compilador lo puede inferir de la declaración. Es eso y un poco de marketing. 

Veamos otro ejemplo: 

public interface Pair<K, V> {

    public K getKey();

    public V getValue();

}

public class OrderedPair<K, V> implements Pair<K, V> {

    private K key;

    private V value;

    public OrderedPair(K key, V value) {

          this.key = key;

          this.value = value;

    }

    public K getKey() { return key; }

    public V getValue() { return value; }

}

Pair<String, Integer> p1 = new OrderedPair<String, Integer>("Even", 8);

Pair<String, String>  p2 = new OrderedPair<String, String>("hello", "world");

OrderedPair<String, Box<Integer>> p = new OrderedPair<>("primes", new Box<Integer>(...));

Y podemos tener métodos genéricos: 

public class Util {

    public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {

        return p1.getKey().equals(p2.getKey()) &&

               p1.getValue().equals(p2.getValue());

    }

}

Por ahora eso es todo de generics. 

Dejo link: 

https://docs.oracle.com/javase/tutorial/java/generics/

Introducción a la programación (javaScript)

Miriada X ha publicado un curso de programación en javascript.

Les dejo más info:

CURSO RECOMENDADO Introducción a la programación (javaScript) Aprende fácilmente JavaScript con el curso mejor valorado en nuestra comunidad y fórmate en un área de gran demanda profesional. Empieza el 30 de octubre y tienes dos semanas para apuntarte. ¡Recomiéndalo! APÚNTATE

"He conseguido aprender a programar. Entre los videos y las respuestas de los compañeros he resuelto mis dudas" "Quería refrescar conocimientos de Javascript. Se ha cumplido a la perfección" "Para ser introducción y poderlo realizar sin conocimientos previos está muy bien diseñado" "Quiero agradecer a los profesores por su buena disposición para contestar las preguntas que surgieron... buen curso"

Con el Nuevo certificado de Superación ¡GRATIS! Sólo al completar este curso APÚNTATE AHORA

De F# a Javascript con Fable

Un lector del blog se le ocurrió la genial idea de compartir el link de Fable en un post de ELM. Y estuve leyendo y me intereso bastante.

A todo el mundo al parecer le interesa compilar lenguajes a javascript, y claro, si se esta volviendo muy famoso y omnipresente. Y F# no quiere ser menos, tomando la idea de ELM nace Fable que es un compilador de F# a html y javascript.



Dejo un video:

Dejo link: https://fable.io/

Colecciones en smalltalk

Como verán sigo leyendo sobre Smalltalk, ahora nos toca ver las colecciones:

Smalltalk cuenta con un framework de colecciones muy poderoso.  No es de extrañar ya que lleva más de 20 años de depuración.

Contamos con numerosos tipos de colecciones (Bag, Set, OrderedCollection, Dictionary, Array, etc) y, a su vez, con un rico y extenso protocolo de mensajes.

A continuación enumero algunos de los mensajes que se les puede enviar a todas las colecciones.

#add: Agrega un objeto (dado como argumento) a la colección.

#addAll: Agrega todos los elementos de la colección dada como argumento a la colección receptora del mensaje.

#remove: Remueve un determinado objeto de la colección. Genera un error si el elemento no es parte de la colección.

#remove:ifAbsent: Remueve un determinado elemento de la colección. Evalúa el bloque dado si el elemento no es parte de la colección.

#removeAll: Remueve todos los elementos del receptor que están contenidos en la colección dada en el argumento.

#do: Evalúa el bloque dado como argumento por cada elemento contenido en la colección.  Este es el principal mensaje de las colecciones y prácticamente todo el resto de mensajes están implementados usando el #do: de alguna forma.  Es interesante ver la implementación de, por ejemplo, los mensajes #select:, #collect:, #anyOne, #detect:ifNone:, #do:separatedBy:, etc.

#do:separatedBy: Evalúa el primer bloque dado como argumento por cada elemento contenido en la colección y evalúa el segundo bloque entre elementos.

#select: Evalúa el bloque dado por cada elemento del receptor como argumento.  Colecciona los elementos en los cuales el bloque evalúa a true (verdadero) en una colección del tipo del receptor. Responde esa colección nueva como resultado.

#reject: Similar a #select: pero colecciona los elementos para los cuales el bloque evalúa a false.

#collect: Evalúa el bloque dado por cada elemento del receptor como argumento.  Colecciona los resultados en una colección del tipo del receptor. Responde esa colección nueva como resultado.

#size Responde el tamaño de la colección.

#anyOne Responde algún elemento de la colección.

#atRandom Responde uno de los elementos del receptor de forma aleatoria.

#detect: Evalúa el bloque dado con cada elemento del receptor. Devuelve el primer elemento donde el bloque evalúa a true. Genera un error si ningún elemento es encontrado.

#detect:ifNone: Evalúa el bloque dado con cada elemento del receptor. Devuelve el primer elemento donde el bloque evalúa a true. Evalúa el otro bloque dado si ningún elemento es encontrado y devuelve el resultado de esa evaluación.

#isEmpty Responde si el receptor está vacío y no contiene elementos.

#includes: Responde si el objeto dado es un elemento del receptor.

#includesAllOf: Responde si todos los elementos de la colección dada están incluidos en la colección receptora.

#includesAnyOf: Responde si algunos de los elementos de la colección dada está incluido en la colección receptora.

#allSatisfy: Responde true si el bloque dado se evalúa a true por todos los elementos de la colección receptora.

#anySatisfy: Responde true si el bloque dado se evalúa a true por algunos de los elementos de la colección receptora.

#noneSatisfy: Responde true si el bloque dado se evalúa a false por todos los elementos de la colección receptora.

#occurrencesOf: Responde cuantas veces está incluido el objeto dado en la colección receptora.

Veamos los Conjuntos: El Set es un tipo de colección que no mantiene ningún orden sobre sus elementos y que no permite que un objeto esté contenido más de una vez.

Un Set representa el concepto matemático de conjunto, donde no tiene sentido decir que un elemento está más de una vez ni tiene sentido hablar de orden.

Ejemplos:
| set |
set := Set new.
set add: 'un string'.
set add: 'otro string'.
set add: 'un string'.
set add: 'otro string'.
set add: 'un string'.
set explore.

"convertir colecciones de diferente tipo a Set para remover los duplicados"
#(5 4 1 2 2 2 1 2 1 2 3 4 3 2 3 4 5) asSet.
'un string que tiene muchos caracteres' asSet.

"Los 2 sets contienen sólo un elemento"
(Set with: 1) = (Set with:1 with:1).

"El orden no importa"
(Set with: 1 with: 2) = (Set with:2 with:1).

Browser de Clases en Pharo o smalltalk que es casi lo mismo

Como veran sigo leyendo sobre smalltalk. Ahora vamos a analizar Browser de Clases

Esta herramienta nos permite ver y modificar todas las clases que tenemos en nuestro ambiente. Podemos también crear o eliminar categorías de clases, clases, categorías de métodos y métodos.
Como Pharo está escrito en si mismo, esta herramienta nos permite ver absolutamente todo el funcionamiento de Pharo.  Desde el Compilador hasta las Ventanas, desde los Números Enteros hasta los tipos Booleanos, todo visible y todo modificable.

El browser está compuesto principalmente por 4 paneles superiores y un panel inferior. En los paneles superiores encontraremos - de izquierda a derecha - las Categorías de Clases, las Clases, las Categorías de Métodos y los Métodos.

Categorías de Clase y Métodos: Tanto las categorías de clases como las categorías de métodos no tienen una semántica para el Smalltalk en si mismo, sino que sirven para documentar el diseño agrupando clases y métodos por funcionalidad apuntando a mejorar el entendimiento del sistema por las personas.

En Smalltalk se lee mucho más código del que se escribe, así que todo el entorno promueve la escritura de código limpio y documentado y todo el tiempo que usemos en escribir código limpio es recompensado.

Si seleccionamos una de las opciones del panel, en los paneles subsiguientes veremos la información correspondiente a la selección. Por ejemplo, si seleccionamos en el primer panel la categoría de clases 'Kernel-Objects', veremos en el segundo panel las clases dentro de esa categoría (como Boolean, DependentsArray, False, MessageSend, etc).  De la misma forma, si ahora seleccionamos la clase Boolean en el segundo panel, veremos en el tercer panel las categorías de métodos de esa clase; y si seleccionamos una categoría de métodos como 'controlling' veremos en el último panel los métodos.  Por último, si seleccionamos uno de los métodos, veremos en el panel inferior el código de dicho método.

Programar con Smalltalk es enviar mensajes a objetos que viven en un ambiente. Programar, con Smalltalk, no es más que modificar un ambiente de objetos y adaptarlo a nuestra necesidad.

Spring 5: Functional Web Framework

Leo un post en spring.io titulado: Spring 5: Functional Web Framework. Que de funcional funcional, no tiene mucho. Pero si es una forma declarativa de crear web gracias a las clausuras que vienen en java 8.

Puff, con la primera linea resumí todo.

Bueno, volvamos. Spring 5 viene con novedades entre las cuales esta un nuevo framework declarativo. En verdad me hace recordar a Sinatra. Pero como esta de moda lo funcional, llamemos funcional a cualquier cosa.

Por lo tanto, salvo el nombre que ya lo critique, el framework y el post están  muy interesante. Veamos un ejemplo (del framework)

 public interface PersonRepository {
  Mono<Person> getPerson(int id);
  Flux<Person> allPeople();
  Mono<Void> savePerson(Mono<Person> person);
}

RouterFunction<?> route = route(GET("/person/{id}"),
  request -> {
    Mono<Person> person = Mono.justOrEmpty(request.pathVariable("id"))
      .map(Integer::valueOf)
      .then(repository::getPerson);
    return Response.ok().body(fromPublisher(person, Person.class));
  })
  .and(route(GET("/person"),
    request -> {
      Flux<Person> people = repository.allPeople();
      return Response.ok().body(fromPublisher(people, Person.class));
    }))
  .and(route(POST("/person"),
    request -> {
      Mono<Person> person = request.body(toMono(Person.class));
      return Response.ok().build(repository.savePerson(person));
    }));

Como ven usa un estilo monads.

HttpHandler httpHandler = RouterFunctions.toHttpHandler(route);
ReactorHttpHandlerAdapter adapter =
  new ReactorHttpHandlerAdapter(httpHandler);
HttpServer server = HttpServer.create("localhost", 8080);
server.startAndAwait(adapter);

Y listo!

Para mayor info: https://spring.io/blog/2016/09/22/new-in-spring-5-functional-web-framework

Academia.edu: la red social para investigadores

Academia.edu es una red social gratuita que tiene como objetivo conectar científicos, ofrecerles una plataforma para compartir sus trabajos de investigación y  facilitarles el seguimiento de los artículos que son relevantes para sus campos de estudio.

Esta red social temática está formada por más de 18 millones de usuarios y cuenta con más de 5 millones de publicaciones científicas de todo el mundo.

Academia.edu apuesta por el acceso abierto de la ciencia y pretende revolucionar el proceso editorial tradicional de la revisión por pares, por lo que permite publicar el texto completo de los libros, artículos, borradores y diversos materiales para acelerar la visibilidad las investigaciones realizadas.


Dejo link:
https://www.academia.edu/