10 ebook populares del 2017

Me llego este mail y como la mayoría de los libros son gratuitos, lo quiero compartir:

Download the Top 10 eBooks!     10) Getting Started with Git Find out what sets Git apart from the more traditional, centralized version controls systems and how it can work for you. Since its inception in 2005, Git continues to grow as the de facto standard for version control in both local and distributed environments. With its beginnings rooted in the open source community, and Linus Torvald’s original authorship, Git’s many features encompass social-driven collaboration that exceeds that of other version control systems.       9) An Introduction to AWS Security AWS is an incredibly rich ecosystem of services and tools, some of which have security aspects baked in (like S3 SSE), and others that provide overarching security capabilities (like IAM and VPC) that apply to many services. With regard to data storage, operating system, and applications, security functions largely the same in the cloud or on-premises software. Customers can and should continue to follow best practices that have served them well in their own data centers.       8) Contemporary Cryptography These slides are intended for computer scientist, electrical engineers, and mathematicians both in research and practice. Cryptography is an enabling technology (or tool) to secure the information infrastructures we build, use, and count on in daily life. Computer scientists, electrical engineers, and applied mathematicians should care about (and be educated in) the principles and applications of cryptography. Download these slides from Prof. Dr. Rolf Oppliger to help continue your Cryptography research.       7) Evolving Along with the Internet of Things The Internet of Things (IoT) is more than a network of smart toasters, refrigerators, and thermostats. They represent just the tip of a very large and mostly invisible iceberg, and the data the IoT generates makes an integrated data strategy more vital than ever. Using that data to produce actionable insights will require fast, accurate, reliable, and scalable infrastructure and processes. This O'Reilly white paper from Teradata looks at why the Internet of Things integrated data strategy more vital than ever.       6) Learn Linux in 5 Days If you want to learn how to use Linux and level up your career but are pressed for time, read on. In this eBook, you will learn the most important concepts and commands, and be guided step-by-step through several practical and real-world examples. As new concepts, commands, or jargon are encountered they are explained in plain language, making it easy to understand. The most important material is condensed into five sections, each designed to be consumed in a day.       5) Amazon Web Services: An Overview There's a great chance that AWS has more than a few products to help you work faster, smarter, and more cost effectively. So, where should you start? Getting a clear understanding of what Amazon Web Services (AWS) is and how it can help your business can be a daunting task. The depth and breadth of AWS is significant, comprising more than 48 services in dozens of data centers located at 11 Regions throughout the globe. They offer computing, storage, networking, deployment, management, and a host of supporting services like queues and email.       4) Dive Into Python (Free 328p. eBook) Python from novice to pro: Whether you're an experienced programmer looking to get into Python or grizzled Python veteran who remembers the days when you had to import the string module, Dive Into Python is your 'desert island' Python book.       3) The Beginners Guide to NoSQL Take advantage of noSQL by learning the basics and more with this FREE eBook. We are storing more data now than we ever have before and connections between our data are growing all the time. We don't make things knowing the structure from day one. Server architecture is now at a stage where we can take advantage of it.       2) Jump Start GIT ($30 Value, FREE) Take control of your code and assets with this descriptive FREE eBook. This book includes: An outline of the philosophy of version control, Exploring Git through the basics and command line, Using Git in a team environment, The "branching" option of Git, Specific tools for efficiency, Examining GUI tools, Using Git for purposes other than code versioning.       1) Learning Python Learn to code like a professional with Python - an open source, versatile, and powerful programming language. Learning Python has a dynamic and varied nature. It reads easily and lays a good foundation for those who are interested in digging deeper. Starting with the fundamentals of programming and Python, it ends by exploring very different topics, like GUIs, web apps and data science. The book takes you all the way to creating a fully fledged application.

Comparando F# con C# parte 2

Ahora, implementaremos un el algoritmo quicksort para ordenar listas y lo haremos en F# y C# para compararlos.

Para el que no conoce el algoritmo quicksort, vamos a ver la lógica:

Si la lista está vacía, no hay nada que hacer.
De otra manera:

1. Tome el primer elemento de la lista, que lo llamaremos pivot
2. Buscamos todos los elementos menores al pivot y los ordenamos usando el algoritmo quicksort.
3. Buscamos todos los elementos mayores al pivot y los ordenamos usando el algoritmo quicksort.
4. Combinamos las tres partes para obtener el resultado final: (elementos menores + pivot + elementos mayores)

Tenga en cuenta que hemos simplificado este algoritmo para hacer la explicación más simple.

Veamos el código en F#:

let rec quicksort list =

   match list with

   | [] ->                            // Si la lista es vacia

        []                            // retorna una lista vacia

   | firstElem::otherElements ->      // si no es vacia

        let smallerElements =         // toma los menores

            otherElements             

            |> List.filter (fun e -> e < firstElem) 

            |> quicksort              // y los ordena

        let largerElements =          // toma los mayores 

            otherElements 

            |> List.filter (fun e -> e >= firstElem)

            |> quicksort              // y los ordena

        // concatena estas 3 partes y la retorna. 

        List.concat [smallerElements; [firstElem]; largerElements]

//test

printfn "%A" (quicksort [1;5;23;18;9;1;3])

Repasemos el código:

No hay declaraciones de tipos en ningún lado. Esta función funcionará en cualquier lista que tenga elementos comparables (que es casi todos los tipos F#, ya que automáticamente tienen una función de comparación predeterminada).
Toda la función es recursiva: esto se señala al compilador utilizando la palabra clave rec en "let rec quicksort list =".
Con  match..with se esta usando pattern matching, las expresiones son como esta:

match x with
| caseA -> something
| caseB -> somethingElse

El pattern matching es una técnica que analiza objetos y ejecuta el código que corresponde (cuando el objeto aplica le patron)

De esta manera se pregunta si la lista es vacía, y si es vacía se retorna una lista vacía.
De lo contrario, aplica la lógica descrita anteriormente. Es decir filtra la lista de los menores por medio de una función anónima que se pasa como clausura, que indica como se va a filtrar y luego se ordena utilizando quicksort, luego filtra la lista de los mayores y los ordena .  Y por ultimo se retorna la concatenación de estas 3 partes.                                                                                                     ,

Veamos la implementación en C# sin LinQ :

public class QuickSortHelper
{
   public static List<T> QuickSort<T>(List<T> values)
      where T : IComparable
   {
      if (values.Count == 0)
      {
         return new List<T>();
      }
     // Tomamos el primer valor
     T firstElement = values[0];
     // Filtramos los elementos
      var smallerElements = new List<T>();
      var largerElements = new List<T>();

      for (int i = 1; i < values.Count; i++)   {
 
         var elem = values[i];
 
         if (elem.CompareTo(firstElement) < 0)
         {
            smallerElements.Add(elem);
         }
         else
         {
            largerElements.Add(elem);
         }
      }

      result.AddRange(QuickSort(smallerElements.ToList()));
      result.Add(firstElement);
      result.AddRange(QuickSort(largerElements.ToList()));
      return result;
   }
}

Comparando los dos programas, nuevamente podemos ver que el código F# es mucho más compacto, con menos ruido y sin necesidad de declaraciones de tipo.

Además, el código F# se lee casi exactamente como es algoritmo, a diferencia del código C#. Esta es otra ventaja clave de F# - el código es generalmente más declarativo ("qué hacer") y menos imperativo ("cómo hacerlo") que C#, y por lo tanto es mucho más autodocumentado.

Veamos una versión más funcional en C#:

public static class QuickSortExtension
{
     public static IEnumerable<T> QuickSort<T>(
        this IEnumerable<T> values) where T : IComparable
    {
        if (values == null || !values.Any())
        {
            return new List<T>();
        }

        var rest = values.Skip(1);
                .Where(i => i.CompareTo(firstElement) < 0)
                .QuickSort();

        var largerElements = rest
                .Where(i => i.CompareTo(firstElement) >= 0)
                .QuickSort();
     
        return smallerElements
            .Concat(new List<T>{firstElement})
            .Concat(largerElements);
    }
}

Esto es mucho más limpio, y lee casi lo mismo que la versión F#.

Finalmente, el código F# a menudo funciona la primera vez, mientras que el código C# puede requerir más depuración.

Pero incluso la ultima versión funcional C# tiene inconvenientes en comparación con la versión F#. Por ejemplo, como F# usa la coincidencia de patrones, no es posible derivar al caso de la "lista no vacía" con una lista vacía.

Dejo link: https://fsharpforfunandprofit.com/posts/fvsc-quicksort/

Diferencia entre ArrayList y LinkedList en Java

Este post lo podría haber hecho hace mucho pero bueno hace poco que me he dado cuenta que esto no es de conocimiento de todos los mortales programadores java.

Antes que nada aclaro que tanto ArrayList como LinkedList implementan la interfaz List y se encuentran en el paquete java.util y son parte de lo que se conoce como java collection framework o jcf para los amigos.

La principal diferencia es un tema de implementación ArrayList implementa la lista con arreglos linkeados, lo que la hace muy eficiente para recorrer pero ineficiente para insertar o eliminar elementos que se no encuentren en el final. En cambio LinkedList es una lista de elementos linkeados (en realidad es una lista doblemente enlazada) lo que la hace lenta para recorrer pero sumamente eficiente para insertar o eliminar elementos. Esta es la principal diferencia y hay que recordarla siempre.

Por lo tanto ArrayList :

• usa internamente un arreglo dinámico para almacenar los elementos.
• proporciona una manipulación lenta 
• es la mejor opción para almacenar y acceder a datos o elementos consecutivos. 

Por lo tanto LinkedList:

• proporciona una manipulación más rápida porque utiliza una lista doblemente enlazada.
• se puede utilizar como lista y cola porque implementa interfaz de List, Deque y Queue.
• es mejor para manipulación de elementos, es decir, para insertar y eliminar elementos.

Por lo tanto si necesitamos agregar elementos consecutivos y recorrerlos debemos utilizar ArrayList y si en cambio necesitamos insertar y eliminar valores no consecutivos debemos usar LinkedList.

Veamos un ejemplo de ArrayList:

import java.util.*;

public class Sample {

          public static void main(String args[]) {
               //Declaring ArrayList
               List<String> l = new ArrayList<String>();
               l.add("Apple");//inserting elements
               l.add("Orange");
               l.add("Mango");
               l.add("Banana");
               l.add("Guava");

               //Traverse the elements by using Iterator interface
               Iterator i = l.iterator();
               while(i.hasNext()) {
                    System.out.println(i.next());
               }
        }
}

Output: Apple
            Orange
            Mango
            Banana
            Guava

Veamos un ejemplo de LinkedList:

import java.util.*;

public class Demo {

    public static void main(String args[]) {
        //Declaring the LinkedList
        LinkedList<String> ll = new LinkedList<String>();
        ll.add("Red");
        ll.add("Red");
        ll.add("Black")';
        ll.add("Blue");
        ll.add("Pink");
        ll.add("Green");

        //Traversing elements by using Iterator interface
        Iterator i = ll.iterator();
        while(i.hasNext()) {
            System.out.println(i.next())
        }
    }
}

Output: Red
             Red
             Black
             Blue
             Pink
             Green

Dejo link: 

https://docs.oracle.com/javase/7/docs/api/java/util/LinkedList.html

https://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html

Feliz 2018 !!!

Feliz 2018, que todos tus sueños se cumplan, que aprendas mucho y que enseñes aun más.

Gracias por leer!!

StringJoiner la nueva clase en Java 8

Java 8 se viene con todo y ahora vamos a ver la clase StringJoiner. Para que sirve? como su nombre lo indica se utiliza para construir una secuencia de caracteres separados por delimitadores, es decir, puede crear cadenas utilizando algunos delimitadores como "," (coma) y "-" (guión), etc. También podemos usar prefijos y sufijos para la secuencia de caracteres.

StringJoiner se encuentra en el paquete java.util y es una clase que es final y extiende de object.

Tiene 2 constructores:

• StringJoiner(CharSequence delimiter). 
• StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix). 

En el primero solo le pasamos el delimitador y en el segundo le pasamos el delimitador, el prefijo y sufijo de la cadena que vamos a formar. 

Entre los métodos más importantes podemos nombrar: 

• StringJoiner add(CharSequence newElement) : Agrega un elemento
• int length() : cantidad de caracteres. 
• StringJoiner merge(StringJoiner other): une 2 secuencias. 
• StringJoiner setEmptyValue(CharSequence emptyValue) : Definimos que valor va a retornar si la secuencia en vacía.  
• String toString() : Retorna la cadena 

Veamos unos ejemplos: 

import java.util.*;

class Demo {

    public static void main(String args[]) {

        StringJoiner sj = new StringJoiner(",");//passing comma (,) as delimiter

        StringJoiner sj1 = new StringJoiner("-");//passing hyphen (-) as delimiter

        //Adding some string with comma(,) delimiter

        sj.add("suresh");

        sj.add("gurpreet");

        sj.add("piyush");

        sj.add("jagdish");

        System.out.println(sj);

        System.out.println();

        //Adding some string with hyphen(-) delimiter

        sj1.add("simran");

        sj1.add("siya");

        sj1.add("khusboo");

        sj1.add("barkha");

        System.out.println(sj1);

    }

}

Output: suresh,gurpreet,piyush,jagdish

             simran-siya-khusboo-barkha

Recordemos que System.out.println utiliza el metodo toString para imprimir un objeto. 

Veamos un ejemplo con sufijo y prefijo: 

import java.util.StringJoiner;

class Demo1 {

    public static void main(String args[]) {

        //passing , as delimiter and using "(" opening bracket as prefix and ")" closing bracket as suffix.

        StringJoiner sj = new StringJoiner(",","(",")");

        sj.add("blue");

        sj.add("red");

        sj.add("pink");

        sj.add("white");

        System.out.println(sj);

    }

}

Output: (blue,red,pink,white)

Veamos ahora un ejemplo con merge: 

import java.util.*;

class Demo3 {

    public static void main(String args[]) {

    //Creating first StringJoiner with delimiter and prefix and suffix

        StringJoiner sj1 = new StringJoiner(",","*","*");

        sj1.add("rose");

        sj1.add("lotus");

        System.out.println(sj1);

        //Creating second StringJoiner with delimiter and prefix and suffix

        StringJoiner sj2 = new StringJoiner(":","*","*");

        sj2.add("red");

        sj2.add("pink");

        System.out.println(sj2);

        //Now using merge() method for merging sj1 and sj2 joiners

        StringJoiner mrg = sj1.merge(sj2);

        System.out.println(mrg);

    }

}

Output: *rose,lotus*

              *red:pink*

              *rose,lous,red:pink*

Y por ultimo un ejemplo integrador: 

import java.util.*;

class Demo4 {

public static void main(String args[]){

    StringJoiner sj1 = new StringJoiner(",");

    /* if StringJoiner is empty then we can print a massage for this StringJoiner by using setEmptyValue(). */

    sj1.setEmptyValue("This is empty StringJoiner");

    System.out.println(sj1);

    System.out.println("add some values");

    //now adding some string by using add() method

    sj1.add("c++");

    sj1.add("html");

    System.out.println("added values is: "+sj1);

    //After adding values, let's count the length of string by using length() method

    int length = sj1.length();

    System.out.println("Length of SJ "+length);

    }

}

Output: This is empty StringJoiner

              add some values

              added values is: c++,html

              Length of SJ 8

Dejo link: https://docs.oracle.com/javase/8/docs/api/java/util/StringJoiner.html

Comparando F# con C#

Vamos a comparar C# con F# a traves de un ejemplo, una suma simple. El problema es simple: "sumar los cuadrados de 1 a N".

Primero, veamos el código F# :

// define the square function
let square x = x * x

// define the sumOfSquares function
let sumOfSquares n =
   [1..n] |> List.map square |> List.sum

// try it
sumOfSquares 100

Y listo, como podemos ver podemos utilizar el operador |> para que la salida de una función, sea entrada de otra. Es similar a el operador |> de elixir.

Si vemos la linea: let sumOfSquares n = [1..n] |> List.map square |> List.sum

1. Crea una lista de enteros de 1 a n. 
2. Luego toma esa lista y aplica una función square usando la biblioteca llamada List.map.
3. Luego acumula todos los elementos de la lista resultante. 

Ahora veamos una implementación en C# utilizando el estilo clásico (no funcional) :

public static class SumOfSquaresHelper
{
   public static int Square(int i)
   {
      return i * i;
   }

   public static int SumOfSquares(int n)
   {
      int sum = 0;
      for (int i = 1; i <= n; i++)
      {
         sum += Square(i);
      }
      return sum;
   }
}

¿Cuáles son las diferencias?

• El código F# es más compacto
• El código F# no tenía ninguna declaración de tipo
• Con F# podemos desarrollar interactivamente

La diferencia más obvia es que hay mucho más código C#. 13 líneas en C# en comparación con 3 líneas en F# (ignorando los comentarios). El código C# tiene mucho "ruido", cosas como llaves, puntos y comas, etc. Y en C# las funciones no pueden estar solas, sino que deben agregarse a alguna clase ("SumOfSquaresHelper"). F# usa espacios en blanco en lugar de paréntesis, no necesita terminador de línea y las funciones pueden ser independientes.

En F#, es común que las funciones completas se escriban en una línea, como la función "cuadrada". La función sumOfSquares también podría haber sido escrita en una línea. En C# esto es mal visto y es considerado una mala práctica.

Cuando una función tiene múltiples líneas, F# usa indentación para indicar un bloque de código, lo que elimina la necesidad de llaves. (Si alguna vez ha usado Python, esta es la misma idea). Entonces la función sumOfSquares también podría haber sido escrita de esta manera:

let sumOfSquares n = 

   [1..n] 

   |> List.map square 

   |> List.sum

La siguiente diferencia es que el código C# tiene que declarar explícitamente todos los tipos utilizados. Por ejemplo, el parámetro n es de tipo int y el tipo de retorno SumOfSquares es int. Sí bien, C# permite usar la palabra clave "var" en muchos lugares, pero no para los parámetros y tampoco para tipos de funciones.

En el código F#, no declaramos ningún tipo. Este es un punto importante: F# parece un lenguaje sin tipo o de tipado dinámico, pero en realidad es igual de seguro que C#, de hecho, ¡aún más! F# usa una técnica llamada "inferencia de tipo" para inferir los tipos que está utilizando desde su contexto. Funciona increíblemente bien la mayor parte del tiempo, y reduce la complejidad del código inmensamente.

En este caso, el algoritmo de inferencia de tipo observa que comenzamos con una lista de enteros. Esto a su vez implica que la función cuadrada y la función suma también deben tomarse, y que el valor final debe ser un int. Puede ver cuáles son los tipos inferidos mirando el resultado de la compilación en la ventana interactiva. Verás algo como:

val square : int -> int

lo que significa que la función "cuadrado" toma un int y devuelve un int. Esta notación me recuerda mucho a Haskell o Scala.

Si la lista original hubiera utilizado flotantes en su lugar, el sistema de inferencia tipo habría deducido que la función cuadrada utilizada flotantes en su lugar:

// define the square function

let squareF x = x * x

// define the sumOfSquares function

let sumOfSquaresF n = 

   [1.0 .. n] |> List.map squareF |> List.sum  // "1.0" is a float

sumOfSquaresF 100.0

¡La verificación de tipos es muy estricta! Si intenta usar una lista de flotantes ([1.0..n]) en el ejemplo original sumOfSquares, o una lista de ints ([1 ..n]) en el ejemplo sumOfSquaresF, obtendrá un error de tipo del compilador.

Finalmente, F# tiene una ventana interactiva donde puedes probar el código inmediatamente y jugar con él. En C# no hay una manera fácil de hacer esto.

Por ejemplo, puedo escribir mi función cuadrada e inmediatamente probarla:

// define the square function

let square x = x * x

// test

let s2 = square 2

let s3 = square 3

let s4 = square 4

Muchas personas afirman que el diseño de códigos impone de forma interactiva buenas prácticas de diseño, como el desacoplamiento y las dependencias explícitas, y por lo tanto, el código que es adecuado para la evaluación interactiva también será un código que es fácil de probar. Por el contrario, el código que no se puede probar de forma interactiva probablemente también sea difícil de probar.

El ejemplo anterior fue escrito usando C# viejo. C# ha incorporado muchas características funcionales, y es posible reescribir el ejemplo de una manera más compacta utilizando las extensiones LINQ.

Así que aquí hay otra versión C#: 

public static class FunctionalSumOfSquaresHelper
{
   public static int SumOfSquares(int n)
   {
      return Enumerable.Range(1, n)
         .Select(i => i * i)
         .Sum();
   }
}

Sin embargo, además del ruido de las llaves, los puntos y los puntos y comas, la versión C# necesita declarar el parámetro y los tipos de retorno, a diferencia de la versión F#.

Si bien el ejemplo fue trivial, nos permitio revisar las deferencias entre F# y C#.

Dejo link: https://fsharpforfunandprofit.com/posts/fvsc-sum-of-squares//

Referencia a metodos en Java 8

Java 8 trae muchas mejoras, tal vez la más importante es que podemos utilizar clausuras o closures en ingles. Pero a la vez Java 8 trae una cantidad interesantes de métodos que utilizan esta nueva propiedad, y a la vez nos brindan mayor facilidad para resolver problemas.

La referencia del método Java 8 se usa para referirse a un método y para hacer que el programa o código sea simple o claro, puede usar la referencia al método en lugar de una expresión lambda.

En resumen esta notación abrevia la expresión lambda para llamar a cualquier método.

El operador '::' se usa como referencia de método. Veamos algunos tipos de referencias de método:

• Referencia a un método de una instancia: object :: instanceMethod
• Referencia a un método estático: Class :: staticMethod
• Referencia a un método de instancia de un objeto arbitrario de un tipo particular:  Class :: instanceMethod
• Referencia a un constructor: Class :: new

En la siguiente  imagen podemos ver la referencia y la expresión lambda que reemplaza:

Veamos unos ejemplos: 

Referencia a un método de una instancia:

@FunctionalInterface

interface Demo {

    void show();

}

public class Test {

    public void display() {

        System.out.println("I am instance method");

    }

    public static void main(String args[]) {

        Test t = new Test();

        Demo d = t :: display;//performing method reference using object

        d.show();//calling method of function interface

    }

}

Output: I am instance method

Referencia a un método estático:

@FunctionalInterface
interface Demo1 {
    void show();
}

class Test1 {
    public static void display() {
        System.out.println("Hi, i am static method of a class");
    }

    public static void main(String args[]) {
        Demo1 dd = Test1 :: display;
        dd.show();
    }
}

Output: Hi, i am static method of a class

Referencia a un método de instancia de un objeto arbitrario de un tipo particular:

import java.util.Arrays;

class Test {

    public static void main(String args[]) {
        String str[] = {"pink", "orange", "black", "red"};
        Arrays.sort(str, String :: compareToIgnoreCase);

        for(String str1 : str) {
            System.out.println(str1);
        }
    }
}

Output: black
             orange
             pink

             red

Referencia a un constructor:

interface Demo4 {
    FullName show(String s);
}

class FullName {
    FullName(String s) {
        System.out.println(s);
    }
}

class Test {
    public static void main(String args[]) {
        Demo4 d = FullName :: new;//performing constructor reference
        d.show("Anurag Singh");
    }
}


Output: Anurag Singh

Dejo link: https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html

Ordenar un arreglo en paralelo en Java 8

Java 8 trae muchas mejoras, tal vez la más importante es que podemos utilizar clausuras o closures en ingles. Pero a la vez Java 8 trae una cantidad interesantes de métodos que utilizan esta nueva propiedad, y a la vez nos brindan mayor facilidad para resolver problemas.

A la vez Java 8 proporciona una nueva característica que es ordenar un vector en paralelo. El método Arrays.sort() se usa para ordenar, pero java 8 proporciona un método nuevo que es el método parallelSort() para ordenar paralelamente los elementos de un vector.

El método parallelSort() pertenece a la clase Arrays, que está disponible en el paquete java.util. El método parallelSort() es más rápido que el método Array.sort() y este método sigue a fork / join framework para asignar las tareas de clasificación a varios subprocesos que están disponibles en el grupo de subprocesos. El método parallelSort () está sobrecargado para todos los tipos de datos primitivos y objetos que implementen Comparable<T>.

Veamos un simple ejemplo de como ordenar con este metodo:

import java.util.Arrays;

class ParallelSortExample
{
      public static void main(String args[]) {
            //Creamos un vector de enteros
            int a[] = {50, 10, 90, 40, 80};
            //Ahora los ordenamos
            Arrays.parallelSort(a);
            for(int i : a) {
                  System.out.println(i);
            }
      }
}

Output: 10
             40
             50
             80
             90

También podemos pasarle un Comparator que indique como debe ordenar, veamos un ejemplo:

package com.concretepage;

import java.util.Arrays;
import java.util.Comparator;
import java.util.function.Consumer;

public class ParallelSortWithComparator {

      public static void main(String[] args) {
             User[] users = User.getUsers();
            Comparator<User> ageComparator = Comparator.comparing(User::getAge);
            System.out.println("--Sort complete array--");
            Arrays.parallelSort(users, ageComparator);
            Consumer<User> printUser = u-> System.out.println(u.getName()+"-"+u.getAge());
            Arrays.stream(users).forEach(printUser);
            System.out.println("--Sort array from index 1 to 4--");
            users = User.getUsers();
            Arrays.parallelSort(users, 1, 4, ageComparator);
            Arrays.stream(users).forEach(printUser);
      }

}

Feliz navidad

Feliz navidad para todos y todas!!

Ukui desktop para Debian, Ubuntu y derivados

¡Útil, conveniente e intuitivo!

UKUI es un entorno de escritorio ligero basado en plugins para Linux y otras distribuciones Unix. Proporciona una experiencia más simple y agradable para navegar, buscar y administrar su equipo. Fue desarrollado utilizando GTK y Qt.

Veamos una imagenes:

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

Un resumen de Scala for the Impatient, parte 35

Operadores de asignación.

Los operadores de asignación tienen la forma operador= y se utilizan de la siguiente forma:

a operator= b

que es igual a decir :

a = a operator b

Por ejemplo a+= b es equivalente a escribir a = a + b

Hay unos detalles técnicos :
<=, >= y != no son operadores de asignación
Un operador que comienza con = nunca es un operador de asignación (==, ===, =/=, etc)
Si a tiene un operador llamado operator= entonces este sera llamado directamente.

Precedencia.

Cuando tenemos más de un operador, sin paréntesis debemos definir las precedencias de los operadores. Dado que esto define el orden de resolución, por ejemplo :

1 + 2 * 3

El operador * se evalúa primero y luego la suma, esto fue definido por conversión. Lenguajes como C++ y Java tienen un numero fijo de operadores por lo tanto es más sencillo definir la precedencias (se pueden enumerar). En cambio en Scala tenemos un numero arbitrario de operadores por lo que se debe definir esto de forma general.

Excepto para los operadores de asignación, la precedencia está determinada por el primer carácter del operador.

Precedencia más alta: un carácter de operador que no sea los de abajo
* / %
+ -
:
< >
! =
&
^
|

Un carácter que no es un carácter de operador
Prioridad más baja: operadores de asignación

Los caracteres en la misma fila producen operadores con la misma precedencia. Por ejemplo, + y -> tienen la misma precedencia.

Los operadores de Postfijos tienen una precedencia menor que los operadores de infijo:

a infixOp b postfixOp es igual a escribir : (a infixOp b)postfixOp


Asociatividad

Cuando hay un conjunto de operadores con la misma precedencia entra en juego la asociatividad, es decir si resuelve de derecha a izquierda o izquierda a derecha. En scala todos los operadores son asociativos por la izquierda excepto:

• Los operadores que terminan en :
• Los operadores de asignación

Por ejemplo el operador :: construye una lista por medio de asociatividad por la derecha:

1 :: 2 :: 3 :: Nil

esto significa

1 :: (2 :: (3 :: Nil))

Esto es así porque necesita construir primero la lista 3 :: Nil para que este parámetro sea usado por le expresión 2 :: (3 :: Nil)

La expresión 3 :: Dicha expresión es igual a la expresión Nil.::(3)

Un resumen de Scala for the Impatient, parte 34

Si hemos programado en C++ recordaremos que nos permite sobrescribir operadores, pero esto requería una muy pesada definición. Esto es muy diferente en Scala, las definiciones son mucho más fáciles y claras.

Sobrescribir operadores nos da una sintaxis más clara de nuestro código y nos acerca a la notación matemática.

En esta parte veremos como definir operadores binarios y unarios. Pero antes debemos aclarar algunos conceptos.

Identificadores

El nombre de las variables, funciones, clases, etc. se denominan identificadores. En Scala tenes más opciones de nombres para los identificadores que en java. Por supuesto podemos hacerlo igual que java, una letra seguida de letra o dígito. Como Java también permite caracteres unicode, es decir :

 es una variable valida.

También se puede utilizar caracteres de operadores en identificadores como :

• Caracteres ASCII como ! # % & * + - / : < = > ? @ \ ^ | ~ , dígitos, . , ; marcas de puntuación, guión bajo, paréntesis () [] {} o comillas “ ' `     
• Caracteres de símbolos matemáticos

Por ejemplo

es un identificador valido y se puede hacer:

de esta manera podemos escribir

de forma valida.

Note que las palabras :  @ # : = _ => <- <: <% >: fi  ̈ son palabras reservadas.

Por lo dicho anteriormente este es una variable valida:

val happy_birthday_!!! = "Bonne anniversaire!!!"

Por ultimo se puede incluir cualquier conjunto de palabras en `` como por ejemplo:

val `val` = 42

Si bien no parece útil, lo es por ejemplo si deseamos llamar a un método java que sea palabra reservada en scala, de esta forma podremos hacerlo.

Operador infijo

Se puede escribir:

a identificador b

Donde identificador es un método con 2 parámetros. Uno implícito y el otro explicito. Por ejemplo:

1 to 10

Que es igual a llamar 1.to(10)

Esto se denomina una expresión infija porque se encuentra entre los 2 parámetros. El operador puede contener letras o no, como el caso de -> :

1 -> 10 es igual a 1.->(10)

Para definir un operador en una clase, solo debe definir un método con el nombre del operador. Por ejemplo la clase Fraction:

class Fraction(n: Int, d: Int) {
    private val num = ...
    private val den = ...
    ...
    def *(other: Fraction) = new Fraction(num * other.num, den * other.den)
}

Operadores unarios

Los operadores infijos son binarios, es decir necesitan 2 parámetros. Un operador con un parámetro se lo denomina unario.

Los cuatro operadores: -, +, !, ~ se pueden utilizar como operadores prefijos, es decir se puede escribir el operador y luego el parámetro como por ejemplo :

 -a es idual a llamar a : a.unary_-

Si es postfijo, en ese caso no hay problema, se puede llamar el método con . o espacio, por ejemplo :

12 toString

es igual a llamar a : 12.toString()

Cuando utilizamos el operador unario postfijo con espacio y sin paréntesis nos puede dar un error de compilación. Dado que no queda expresado que no estamos utilizando parámetros. Veamos un ejemplo:

val result = 42 toString
println(result)

En este caso el compilador interpreta que se esta escribiendo lo siguiente :

val result = 42.toString(println(result))

Por esta razón nos lanzara un error de compilación, que dirá que el método tiene muchos parámetros. Por esta razón el compilador, lanza un warning cuando utilizamos esta notación, esto se puede desactivar con el parámetro del compilador -language:postfixOps o agregando el import :

import scala.language.postfixOps

Goland, la nueva ide de Jetbrains para Go.

Una empresa que esta haciendo las cosas bien hace tiempo es Jetbrains y ahora ha lanzado una IDE para Go. Si no recuerdan bien Go es el lenguaje de google, que espera remplazar a c.

Como podemos ver Jetbrains suma un IDE a su lista de productos como PyCharm para Python y RubyMine para Ruby.

De GoLands podemos nombrar algunas de las características como:

• Asistente de programación: al analizar el código fuente, proporciona características como la finalización del código, la navegación, la refactorización y el formateo, todos ellos específicos de Go.
• Editor de código: resaltado de sintaxis y sugerencias de parámetros para facilitar la lectura y comprensión del código
• Diseño ergonómico: la interfaz ha sido diseñada de la manera más directa y productiva posible
• Desarrollo de front-end y back-end: soporte de primera clase para lenguajes y frameworks front-end, y herramientas para acceder y consultar bases de datos
• Herramientas integradas: Herramientas comúnmente requeridas como depuradores, integración de control de versiones y corredores de prueba vienen instalados y no necesitan instalarse como complementos
• Ecosistema de plugins: el ecosistema de plugins existente de JetBrains está disponible, abriendo muchas herramientas y características adicionales
• Los desarrolladores que ya están familiarizados con IntelliJ se sentirán a gusto programando en go. 

La herramienta de depuración incluida también es similar a las de las suites de herramientas existentes de JetBrains. Los desarrolladores ahora podrán pasar por el código, agregar puntos de interrupción, evaluar expresiones, agregar relojes y más. Esto trae una modernización a aquellos más familiarizados con flujos de trabajo de depuración más débiles.

JetBrains planea expandir y mejorar este conjunto de características de forma regular, siguiendo el ciclo de lanzamiento típico de todas sus herramientas: las actualizaciones de versiones principales se realizarán trimestralmente, y las versiones menores y de parches suceden incluso con mayor frecuencia.

GoLand sigue el modelo estándar de licencia de JetBrains, con una prueba inicial de 30 días seguida de suscripciones mensuales o anuales, disponible tanto para individuos como para empresas. Para los usuarios de IntelliJ ultimate edition, su funcionalidad se puede instalar como un complemento.

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

Primeros pasos con F#

Si bien hemos hablado de F# en el blog nunca hice un post del lenguaje en si, bueno vamos a cambiar eso.

Si vamos a la pagina de F# nos dira que es un lenguaje open source, multiplataforma y funcional. Capaz de resolver problemas complejos de forma simple.

Por que utilizar o aprender F#?

• Concisión. F # no está lleno de "ruido" de codificación, como llaves, punto y coma, etc. Casi nunca tiene que especificar el tipo de un objeto, gracias a un potente sistema de inferencia de tipo. Y generalmente requiere menos líneas de código para resolver el mismo problema.
• Conveniente. Muchas tareas de programación comunes son mucho más simples en F#. Esto incluye cosas como crear y usar definiciones de tipos complejos, hacer el procesamiento de listas, comparación e igualdad, máquinas de estado y mucho más. Y debido a que las funciones son objetos de primera clase, es muy fácil crear código poderoso y reutilizable creando funciones que tienen otras funciones como parámetros, o que combinan funciones existentes para crear nuevas funcionalidades.
• Exactitud. F# tiene un sistema de tipo muy poderoso que evita muchos errores comunes, como las excepciones de referencia nula. Además, a menudo puede codificar la lógica de negocios utilizando el sistema de tipo en sí, de modo que es realmente imposible escribir código incorrecto, porque se detecta en tiempo de compilación como un error de tipo.
• Concurrencia: F# tiene una serie de herramientas y bibliotecas integradas para ayudar con los sistemas de programación cuando ocurre más de una cosa a la vez. La programación asincrónica es directamente compatible, como lo es el paralelismo. F# también tiene un sistema de cola de mensajes y un excelente soporte para el manejo de eventos y programación reactiva. Y debido a que las estructuras de datos son inmutables por defecto, compartir estado y evitar bloqueos es mucho más fácil.
• Completo. Aunque F # es un lenguaje funcional de corazón, admite otros estilos que no son 100% puros, lo que facilita mucho la interacción con el mundo no puro de sitios web, bases de datos, otras aplicaciones, etc. En particular, F# está diseñado como un lenguaje híbrido funcional / OO, por lo que puede hacer casi todo lo que C# puede hacer también. Por supuesto, F# se integra sin problemas con el ecosistema .NET, que le da acceso a todas las herramientas y bibliotecas .NET de terceros. Finalmente, es parte de Visual Studio, lo que significa que obtiene un buen editor con soporte IntelliSense, un depurador y muchos complementos para pruebas unitarias, control de código fuente y otras tareas de desarrollo.

Aquí hay una descripción general muy rápida sobre cómo leer el código F# para los recién llegados que no estén familiarizados con la sintaxis. La sintaxis F# es muy clara y directa cuando te acostumbras. En muchos sentidos, es más simple que la sintaxis C#, con menos palabras clave y casos especiales.

El siguiente código de ejemplo es un script sencillo de F # que muestra la mayoría de los conceptos que necesita de forma regular.

// single line comments use a double slash
(* multi line comments use (* . . . *) pair -end of multi line comment- *)

// ======== "Variables" (but not really) ==========
// The "let" keyword defines an (immutable) value
let myInt = 5
let myFloat = 3.14
let myString = "hello" //note that no types needed

// ======== Lists ============
let twoToFive = [2;3;4;5]        // Square brackets create a list with
                                 // semicolon delimiters.
let oneToFive = 1 :: twoToFive   // :: creates list with new 1st element
// The result is [1;2;3;4;5]
let zeroToFive = [0;1] @ twoToFive   // @ concats two lists

// IMPORTANT: commas are never used as delimiters, only semicolons!

// ======== Functions ========
// The "let" keyword also defines a named function.
let square x = x * x          // Note that no parens are used.
square 3                      // Now run the function. Again, no parens.

let add x y = x + y           // don't use add (x,y)! It means something
                              // completely different.
add 2 3                       // Now run the function.

// to define a multiline function, just use indents. No semicolons needed.
let evens list =
   let isEven x = x%2 = 0     // Define "isEven" as an inner ("nested") function
   List.filter isEven list    // List.filter is a library function
                              // with two parameters: a boolean function
                              // and a list to work on

evens oneToFive               // Now run the function

// You can use parens to clarify precedence. In this example,
// do "map" first, with two args, then do "sum" on the result.
// Without the parens, "List.map" would be passed as an arg to List.sum
let sumOfSquaresTo100 =
   List.sum ( List.map square [1..100] )

// You can pipe the output of one operation to the next using "|>"
// Here is the same sumOfSquares function written using pipes
let sumOfSquaresTo100piped =
   [1..100] |> List.map square |> List.sum  // "square" was defined earlier

// you can define lambdas (anonymous functions) using the "fun" keyword
let sumOfSquaresTo100withFun =
   [1..100] |> List.map (fun x->x*x) |> List.sum

// In F# returns are implicit -- no "return" needed. A function always
// returns the value of the last expression used.

// ======== Pattern Matching ========
// Match..with.. is a supercharged case/switch statement.
let simplePatternMatch =
   let x = "a"
   match x with
    | "a" -> printfn "x is a"
    | "b" -> printfn "x is b"
    | _ -> printfn "x is something else"   // underscore matches anything

// Some(..) and None are roughly analogous to Nullable wrappers
let validValue = Some(99)
let invalidValue = None

// In this example, match..with matches the "Some" and the "None",
// and also unpacks the value in the "Some" at the same time.
let optionPatternMatch input =
   match input with
    | Some i -> printfn "input is an int=%d" i
    | None -> printfn "input is missing"

optionPatternMatch validValue
optionPatternMatch invalidValue

// ========= Complex Data Types =========

// Tuple types are pairs, triples, etc. Tuples use commas.
let twoTuple = 1,2
let threeTuple = "a",2,true

// Record types have named fields. Semicolons are separators.
type Person = {First:string; Last:string}
let person1 = {First="john"; Last="Doe"}

// Union types have choices. Vertical bars are separators.
type Temp =
| DegreesC of float
| DegreesF of float
let temp = DegreesF 98.6

// Types can be combined recursively in complex ways.
// E.g. here is a union type that contains a list of the same type:
type Employee =
  | Worker of Person
  | Manager of Employee list
let jdoe = {First="John";Last="Doe"}
let worker = Worker jdoe

// ========= Printing =========
// The printf/printfn functions are similar to the
// Console.Write/WriteLine functions in C#.
printfn "Printing an int %i, a float %f, a bool %b" 1 2.0 true
printfn "A string %s, and something generic %A" "hello" [1;2;3;4]

// all complex types have pretty printing built in
printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A"
         twoTuple person1 temp worker

// There are also sprintf/sprintfn functions for formatting data
// into a string, similar to String.Format.

Dejo link:

http://fsharpforfunandprofit.com/