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/

Entrando en .NET Core con the Windows Compatibility Pack

Una de las mayores diferencias entre .net y .net core es que este ultimo corre en Linux. Pero para aplicaciones de grandes empresas, realizar una migración en un solo paso no es factible. Por este motivo, Microsoft recomienda una transición incremental:

Migrar a ASP.NET Core
Migrar a .NET Core
Migrar a Linux
Y luego Migrar a Azure (host en linux)

Si bien eso suena bien en teoría, si falta una API crítica los proyectos no llegarán ni al paso 2. En este caso es donde entra en juego he Windows Compatibility Pack para .NET Core. Abarcando 20,000 APIs, esta colección de paquetes .net tiene como objetivo abordar las necesidades de la librerías para los desarrolladores de aplicaciones web.

Las API recientemente portadas se dividen aproximadamente en dos categorías: solo Windows y multiplataforma. Las API solo de Windows incluyen:

• Active directory
• Criptografia
• Registros de eventos y contadores de rendimiento
• File system security
• Named pipes
• Registry Access
• Windows Services

En su mayor parte, están relacionados con el sistema operativo Windows, y los equivalentes de Linux a menudo tienen un diseño diferente.

Las bibliotecas multiplataforma incluyen:

• Caching
• ConfigurationManager 
• DatasetExtensions (usado para acceso a base de datos sin un ORM) 
• ODBC database access
• System.Configuration.ConfigurationManager (MEF v1)
• System.Drawing
• System.IO.Packaging 
• System.ServiceModel (i.e. WCF)

Cabe señalar que estas API se están omitiendo intencionalmente de la distribución .NET Core completa. 

Dejo link: https://blogs.msdn.microsoft.com/dotnet/2017/11/16/announcing-the-windows-compatibility-pack-for-net-core/

Un resumen de Scala for the Impatient, parte 33

Self type

Cuando un trait extiende de una clase, hay una garantía de que la superclase está presente en cualquier clase que se mezcle con el trait. Scala tiene un mecanismo alternativo para garantizar esto,  se denomina self type.

Cuando un trait comienza con :

this: Type =>

entonces solo se puede mezclar en una subclase del tipo dado.

trait LoggedException extends ConsoleLogger {
    this: Exception =>
    def log() { log(getMessage()) }
}

Note que el trait no extiende de Exception, en cambio, tiene un tipo propio Excepción. Eso significa que solo se puede mezclar en subclases de Excepción.

En los métodos del rasgo, podemos llamar a cualquier método del self type. Por ejemplo, la llamada a getMessage() en el método de registro es válida, ya que sabemos que debe ser un trait extendido por una excepción.

Como se puede suponer si una clase que no sea una Excepción quiere utilizar LoggedException eso no va a compilar.

También se puede utilizar type self con un método determinado, sin especificar una clase.

trait LoggedException extends ConsoleLogger {
    this: { def getMessage() : String } =>
        def log() { log(getMessage()) }
}

Por lo tanto este trait podrá mezclarse con cualquier clase que implemente getMessage() .

Que pasa en la jvm?

Scala necesita pasar un trait a una clase o interfaz java para que esto pueda ser comprendido por la JVM. Y es muy útil entender como trabajan los traits.

Un trait con todos los métodos abstractos es convertido a una interfaz. Un trait con un método es como una interfaz con un método por defecto:

trait ConsoleLogger {
    def log(msg: String) { println(msg) }
}

Se convierte:

public interface ConsoleLogger {
    default void log(String msg) { ... }
}

Si un trait tiene campos, es transformado a una interfaz con los métodos getters y setters:

trait ShortLogger extends Logger {
    val maxLength = 15 // A concrete field
    ...
}

es transformado a:

public interface ShortLogger extends Logger {
    int maxLength();
    void weird_prefix$maxLength_$eq(int);
    default void log(String msg) { ... } // Calls maxLength()
    default void $init$() { weird_prefix$maxLength_$eq(15); }
}

Por supuesto las interfaces en java no tienen campos, por lo que llama a los metodos getters o setters cuando quiera acceder o cambiar este valor. El setter es necesario tambien para inicializar el campo. Esto sucede en el método $init$.

Cuando el rasgo se mezcla en una clase, la clase obtiene un campo maxLength, y el getter y el setter se definen para obtener y establecer el campo. Los constructores de esa clase invocan el método $init$ del trait. Por ejemplo:

class SavingsAccount extends Account with ConsoleLogger with ShortLogger

seria en java:

public class SavingsAccount extends Account
 implements ConsoleLogger, ShortLogger {
   private int maxLength;
   public int maxLength() { return maxLength; }
   public void weird_prefix$maxLength_$eq(int arg) { maxLength = arg; }
 
   public SavingsAccount() {
      super();
      ConsoleLogger.$init$();
      ShortLogger.$init$();
   }
...
}

Top 5 de libros sobre c++

Encontré un buen post sobre libros de c++, y yo justo necesito por lo tanto vamos a pegarle un repaso:

• The C++ Programming Language, 4th Edition : Escrito por Bjarne Stroustrup es la biblia de c++ y la edición 4, nos enseña C++ 11
• C++ Primer Plus (6th Edition) (Developer's Library) :Este libro es también uno de los libros populares de C ++, escrito por Stephen Prata. Es beneficioso tanto para estudiantes o programadores. 
• Starting Out with C++ from Control Structures to Objects (9th Edition): Este libro es el mejor para los principiantes, está escrito por Tony Gaddis. El autor describe el concepto fundamental de una manera clara y fácil que hace que este libro sea amigable para los estudiantes.
• Effective Modern C++ : Este es un excelente libro para el experimentado programador de C ++. El autor describe muy bien cómo escribir un software realmente genial usando C ++ 11 y C ++ 14 (C ++ moderno).
• Accelerated C++: Practical Programming by Example: El libro es sorprendentemente pequeño, en menos de 300 páginas, los autores cubren muchas de las cosas. Cubre un alcance mucho más amplio de la programación C ++ que otros libros introductorios que he visto, y en un formato sorprendentemente compacto.

Dejo link: https://aticleworld.com/best-c-books/#.WicYcwOnLlE.google_plusone_share