Programación Orientada a objetos desde la perspectiva de su creador

Muchos mitos existen sobre la programación orientada a objetos. Una de las cosas que he escuchado diferentes versiones es sobre su creación. Yo prefiero pensar que todo ocurrió en el Centro de Investigación de Palo Alto (PARC - Palo Alto Research Center) de Xerox en 1970.

Alan Kay es el creador de la programación orientada a objetos. Es decir si utilizas poo debes conocer a esta persona.

Kay entró a trabajar en el Centro de Investigación de Palo Alto (PARC - Palo Alto Research Center) de Xerox en 1970. En los setenta fue uno de los miembros principales del centro, desarrollando prototipos de estaciones de trabajo en red, usando el lenguaje de programación Smalltalk. Smalltalk es un lenguaje de poo puro. En Smalltalk todo es un objeto, es de tipado dinámico y con clausuras. Deberían leer sobre este lenguaje.

Kay, junto a algunos compañeros en PARC y otros predecesores del Norwegian Computing Centre, es uno de los padres de la Programación Orientada a Objetos. Creó el Dynabook que definió la base de los ordenadores portátiles y Tablet PC actuales, también es considerado por algunos como el arquitecto de los sistemas modernos de ventanas interfaz gráfica de usuario.

Unas de las frases que más me gustan:

“I invented the term object oriented, and I can tell you that C++ wasn't what I had in mind.” —Alan Kay. (Yo inventé el término "orientado a objetos", y te puedo asegurar que C++ no era en lo que estaba pensando)

Dejo link: http://www.vpri.org

Java 9 elimina CORBA del classpath por defecto.

Es decir la nueva JDK de java 9, no vamos a tener CORBA. La verdad no es una gran noticia, no creo que muchas aplicaciones estén usando CORBA y deseen migrar a Java 9. Pero a pesar de ese detalle la noticia resono en todos los lugares.

Dejo link:
https://www.infoq.com/news/2016/06/corba-removed-java-9

Nim, un nuevo lenguaje!!

Nim es un lenguaje imperativo, multiparadigma, es un lenguaje compilado, de tipado estático. Diseñado para ser eficiente, expresivo y elegante. Soporta metaprogramming, programación funcional, procedural y orientación a objeto.

Veamos un hola mundo:

# This is a comment
echo "What's your name? "
var name: string = readLine(stdin)
echo "Hi, ", name, "!"

Y ahora vamos a compilar:

nim compile --run greetings.nim

Veamos un objeto:

type
  Person = ref object of RootObj
    name*: string  # the * means that `name` is accessible from other modules
    age: int       # no * means that the field is hidden from other modules
 
  Student = ref object of Person # Student inherits from Person
    id: int                      # with an id field

var
  student: Student
  person: Person
assert(student of Student) # is true
# object construction:
student = Student(name: "Anton", age: 5, id: 2)
echo student[]

Entre sus características, podemos nombrar:

• Librería estandar 
• Garbage Collector
• Procedures
• Iterators
• Enumerations
• Modules
• Generics
• Templates
• Macros
• Compilación a javascript
• Aporia es la IDE con la que se pueden programar.

Dejo link:
http://nim-lang.org/
https://github.com/nim-lang/Aporia

Traits en PHP

Buscando sobre traits en scala me encontré con que Php tambien tiene traits desde la versión 5.4.0

Los traits (rasgos) son un mecanismo de reutilización de código en lenguajes de herencia simple, como PHP. El objetivo de un trait es el de reducir las limitaciones propias de la herencia simple permitiendo que los desarrolladores reutilicen a voluntad conjuntos de métodos sobre varias clases independientes y pertenecientes a clases jerárquicas distintas. La semántica a la hora combinar Traits y clases se define de tal manera que reduzca su complejidad y se eviten los problemas típicos asociados a la herencia múltiple y a los Mixins.

Un Trait es similar a una clase, pero con el único objetivo de agrupar funcionalidades muy específicas y de una manera coherente. No se puede instanciar directamente un Trait. Es por tanto un añadido a la herencia tradicional, y habilita la composición horizontal de comportamientos; es decir, permite combinar miembros de clases sin tener que usar herencia.

Para los que vienen de Java es como las interfaces con métodos por defecto de Java 8.

Veamos un ejemplo:

<?php
trait ezcReflectionReturnInfo {
    function getReturnType() { /*1*/ }
    function getReturnDescription() { /*2*/ }
}

class ezcReflectionMethod extends ReflectionMethod {
    use ezcReflectionReturnInfo;
    /* ... */
}

class ezcReflectionFunction extends ReflectionFunction {
    use ezcReflectionReturnInfo;
    /* ... */
}
?>

Los miembros heredados de una clase base se sobrescriben cuando se inserta otro miembro homónimo desde un Trait. De acuerdo con el orden de precedencia, los miembros de la clase actual sobrescriben los métodos del Trait, que a su vez sobrescribe los métodos heredados.

Se sobrescribe un miembro de la clase base con el método insertado en MiHolaMundo a partir del Trait DecirMundo. El comportamiento es el mismo para los métodos definidos en la clase MiHolaMundo. Según el orden de precedencia los métodos de la clase actual sobrescriben los métodos del Trait, a la vez que el Trait sobrescribe los métodos de la clase base.

Veamos un ejemplo:

<?php
class Base {
    public function decirHola() {
        echo '¡Hola ';
    }
}

trait DecirMundo {
    public function decirHola() {
        parent::decirHola();
        echo 'Mundo!';
    }
}

class MiHolaMundo extends Base {
    use DecirMundo;
}

$o = new MiHolaMundo();
$o->decirHola();
?>

y el resultado va a ser:

¡Hola Mundo!

Se pueden insertar múltiples Traits en una clase, mediante una lista separada por comas en la sentencia use.

<?php
trait Hola {
    public function decirHola() {
        echo 'Hola ';
    }
}

trait Mundo {
    public function decirMundo() {
        echo 'Mundo';
    }
}

class MiHolaMundo {
    use Hola, Mundo;
    public function decirAdmiración() {
        echo '!';
    }
}

$o = new MiHolaMundo();
$o->decirHola();
$o->decirMundo();
$o->decirAdmiración();
?>

y el resultado sería:

Hola Mundo!

Hace mucho que no hago algo en PHP, pero se ve a las claras como evoluciono y evoluciona para bien.

Dejo la fuente:
http://php.net/manual/es/language.oop5.traits.php

compose y andThen en scala

Una buena practica de programación es realizar funciones atómicas que luego se puedan reutilizar. Esto nos permite reutilizarlas como parte de otras funciones y hasta como composiciones de funciones. Con este espíritu fueron creadas las funciones compose y andThen en scala.

Con compose puedo componer dos funciones, es decir que se ejecute una y luego con el resultado de la misma ejecutar la segunda función. Sería algo así: f(g(x))

scala> val fComposeG = f _ compose g _
fComposeG: (String) => java.lang.String = <function>

scala> fComposeG("yay")
res0: java.lang.String = f(g("yay"))

De la misma manera funciona andThen  pero en orden de ejecución diferente. Es decir:

scala> val fAndThenG = f _ andThen g _
fAndThenG: (String) => java.lang.String = <function>

scala> fAndThenG("yay")
res1: java.lang.String = g(f(yay))

Dejo link:
https://twitter.github.io/scala_school/pattern-matching-and-functional-composition.html

All About Scala

All About Scala es un sitio donde podes encontrar tutoriales de scala, y tambien de Intellj. Por el momento los tutoriales de scala son un tanto básicos (buenos para comenzar).

Dejo link:
http://allaboutscala.com/tutorials/

PartialFunction en scala

Imaginemos que queremos definir un pattern matching si bien sabemos como se debe comportar con ciertos valores, no tenemos una comportamiento por default. Veamos un ejemplo:

def toYesOrNo(choice: Int): String = choice match {
    case 1 | 2 | 3 => "yes"
    case 0 => "no"
  }

En este caso si trato de usar la función para un valor que no se encuentra definido en el dominio por ejemplo 5. Esto nos dará un error. Pero si utilizamos PartialFunction, no nos devolverá un error y a la vez podemos ver si esta función funciona con ese valor:

scala> val one: PartialFunction[Int, String] = { case 1 => "one" }
one: PartialFunction[Int,String] = <function1>

scala> one.isDefinedAt(1)
res0: Boolean = true

scala> one.isDefinedAt(2)
res1: Boolean = false

Dejo link:
https://twitter.github.io/scala_school/pattern-matching-and-functional-composition.html

The Elements of Web Design

Codescholl nos trae un nuevo curso esta vez de diseño web.
Les dejo los temas:

Course Overview

 Watch Course Intro

1. 

   LEVEL 1 FREE LEVEL 2 Videos | 10 Challenges

   User Discovery

   Begin the design process by identifying and testing your hypothesized target audience.
2. 

   LEVEL 2 2 Videos | 13 Challenges

   Navigating Sites

   Avoid nuclear meltdowns by learning how to organize your content and establish good navigation practices.
3. 

   LEVEL 3 3 Videos | 14 Challenges

   Usability Design

   Learn to create a positive bond with your users with smart, user-related web pages.
4. 

   LEVEL 4 1 Video | 6 Challenges

   Mobile Best Practices

   Yield some positive reactions with tips for designing with mobile in mind.

COMPLETE THESE LEVELS TO UNLOCK

Course Completion Badge

Learn how to design user-centered websites that are purposeful and easy to use.

Dejo link:
https://www.codeschool.com/courses/the-elements-of-web-design

Un montón de cursos en coursera sobre Scala

"Program on a Higher Level" es la especialización que lanzo coursera sobre tecnologías ligadas a Scala.

Los cursos son:

• Functional Programming Principles in Scala
• Functional Program Design in Scala
• Parallel programming
• Big Data Analysis with Scala and Spark

No hay excusas a estudiar!!

Dejo link:
https://www.coursera.org/specializations/scala?utm_content=buffere5926&utm_medium=social&utm_source=linkedin.com&utm_campaign=buffer

Paradigmas de programación

Me encontré en Internet con la siguiente taxonomía de paradigmas de programación y ejemplos de lenguajes. Me pareció por demás interesante, por lo que lo comparto:

Otra cosa que me pareció interesante la definición de paradigma:

Un paradigma de programación es un enfoque a la programación de una computadora basado en una teoría matemática o un conjunto coherente de principios. Cada paradigma admite un conjunto de conceptos que hace que este sea mejor para un determinado tipo de problema.

Dejo link:
https://continuousdevelopment.wordpress.com/2010/02/21/162/

Top de 100 librerías Java

Leyendo dzone me encontré con un articulo por demás interesante. Aprovecho a recomendarles dzone cada vez esta mejor. Tiene una producción muy grande de artículos, imposible leer todo...

Volviendo al tema la gente de dzone tomo las dependencias de los 3862 proyectos más populares de GitHub, y a partir de esos datos han creado un informe sobre las 100 librerías Java más populares.

Como se puede ver junit esta primero cómodo. 

Dejo link: 

https://dzone.com/articles/the-top-100-java-libraries-in-2016-after-analyzing

Estructuras inmutables en java

Si bien no es algo super novedoso pero la verdad es que muchos desarrolladores no saben que se puede modelar estructuras inmutables en Java.

En java hay muchas estructuras inmutables podemos pensar en los String, Integer, BigDecimal or BigInteger.

Estas estructuras representan datos que sería impensable que cambie su estado interno. Es decir son objetos que representan un valor. Podemos pensar en el patrón ValueObject que describe Martin Fowler.

Estas estructuras deben devolver una copia de ellos mismos si desean devolver un resultado pero nunca deben cambiar su valor interno.

Pensemos en representar un objeto fracción para esto debemos codificar una clase:

public class Rational {
    private int num;   // the numerator
    private int den;   // the denominator

    // create and initialize a new Rational object
    public Rational(int numerator, int denominator) {
        if (denominator == 0) {
            throw new RuntimeException("Denominator is zero");
        }
        int g = gcd(numerator, denominator);
        num = numerator   / g;
        den = denominator / g;

    }

    // return string representation of (this)
    public String toString() {
        if (den == 1) return num + "";
        else          return num + "/" + den;
    }

    // return (this * b)
    public Rational times(Rational b) {
        return new Rational(this.num * b.num, this.den * b.den);
    }


    // return (this + b)
    public Rational plus(Rational b) {
        int numerator   = (this.num * b.den) + (this.den * b.num);
        int denominator = this.den * b.den;
        return new Rational(numerator, denominator);
    }

    // return (1 / this)
    public Rational reciprocal() { return new Rational(den, num);  }

    // return (this / b)
    public Rational divides(Rational b) {
        return this.times(b.reciprocal());
    }


   /***************************************************************************
    *  Helper functions
    ***************************************************************************/

    // return gcd(m, n)
    private static int gcd(int m, int n) {
        if (0 == n) return m;
        else return gcd(n, m % n);
    }

}

Como se puede ver cada vez que hacemos una operación devolvemos una copia del objeto:

    // return (this + b)
    public Rational plus(Rational b) {
        int numerator   = (this.num * b.den) + (this.den * b.num);
        int denominator = this.den * b.den;
        return new Rational(numerator, denominator);
    }

Esto nos permite no cambiar el estado interno de los objetos.

Lazy Vals en Scala

Scala permite la palabra clave especial lazy delante de val con el fin de que no inicialice la constante con el valor, si no que este valor se calcule cuando realmente se necesite.

Es decir, si yo tengo lo siguiente:

lazy val a = 2 + 2
val b = a +2

En este caso a se va a calcular en la linea 2 y no en la 1.

Pero esto como funciona?

Dada la expresión 2 + 2, la expresión aún no se evalúa cuando estamos asignando. En el primer acceso (y sólo en la primer acceso) la expresión se evalúa y se devuelve como el resultado (4 en este caso). En cuanto a los accesos posteriores el resultado almacenado de la evaluación se almacena en caché y será devuelto en su lugar, nin necesidad de evaluar 2 veces.

Esta característica llamada "evaluate once" es muy fuerte. Sobre todo si tenemos en cuenta un escenario de multiproceso: Que debería ocurrir si dos subprocesos tienen acceso a nuestro val perezoso al mismo tiempo? Teniendo en cuentade que la evaluación se produce sólo una vez, tenemos que introducir algún tipo de sincronización con el fin de evitar una multiplicidad de evaluaciones de nuestra expresión. En la práctica, esto significa la expresión suma será evaluado por un hilo, mientras que el otro(s) tendrá que esperar hasta que la evaluación se ha completado, después puede ver el resultado evaluado.

Con la palabra  synchronized podemos decir que este campo sea sincronizado.

Lo que esta pasando con la ciencia en Argentina.

No soy de compartir estas cosas y menos de querer meter el blog en política. Pero si apoyo la educación libre, la investigación sin cadenas, la posibilidad de compartir todo conocimiento. De esta única manera vamos a crecer como sociedad.

Quita de subsidios y becas, nos afecta a todos. Sin más los dejo con este video:

Apache Hadoop Cookbook

Quiero compartir este ebook de Hodoop.

En este libro podemos encontrar una recopilación de ejemplos basados en Hadoop que ayudarán a poner en marcha sus proyectos. Este libro cubre una amplia gama de temas, desde la instalación y configuración, para el almacenamiento en caché distribuido y streaming. Con este libro, usted será capaz de obtener sus propios proyectos en marcha y funcionando en un tiempo mínimo.



Dejo link: https://www.javacodegeeks.com/wp-content/uploads/2016/05/Apache-Hadoop-Cookbook.pdf