Java 15 fue liberado!!

 

Y como era de esperar tenemos otra versión de java, que dado que viene tan seguido, se ha perdido la expectativa dado la periodicidad y la cantidad de cosas que tenemos para aprender. 

En esta versión no tenemos grandes cambios a nivel de lenguaje. La lista final completa de características es:

• JEP 339: Edwards-Curve Digital Signature Algorithm (EdDSA)
• JEP 360: Sealed Classes (Preview)
• JEP 371: Hidden Classes
• JEP 372: Remove the Nashorn JavaScript Engine
• JEP 373: Reimplement the Legacy DatagramSocket API
• JEP 374: Disable and Deprecate Biased Locking
• JEP 375: Pattern Matching for instanceof (Second Preview)
• JEP 377: ZGC: A Scalable Low-Latency Garbage Collector
• JEP 378: Text Blocks
• JEP 379: Shenandoah: A Low-Pause-Time Garbage Collector
• JEP 381: Remove the Solaris and SPARC Ports
• JEP 383: Foreign-Memory Access API (Second Incubator)
• JEP 384: Records (Second Preview)
• JEP 385: Deprecate RMI Activation for Removal

Cabe señalar que Java 15 no es una versión de soporte a largo plazo, por lo que queda por ver hasta qué punto los desarrolladores adoptarán esta nueva versión. Hasta la fecha, ninguna de las versiones que no son LTS ha tenido una adopción significativa.

Dejo link: https://jdk.java.net/15/

Y si la quieren descargar la versión libre : 

https://adoptopenjdk.net/

Ecuaciones en Haskell

Para los que venimos de otros lenguajes, tenemos que saber que no hay ecuaciones en lenguajes imperativos. En Haskell las ecuaciones se utilizan para dar nombre a los valores.

respuesta = 42

Una ecuación en Haskell es una ecuación matemática: dice que el lado izquierdo y el lado derecho denotan el mismo valor.

El lado izquierdo debe ser un nombre al que le esté dando un valor. Por ejemplo : 

   x = 5 * y

No podemos escribir ecuaciones como lo hacemos en la matemática, por ejemplo esto esta mal : 

   2 * x = (3 * x) ** 2 - No se permite la reasignación en un FPL puro

Las ecuaciones no son asignaciones y una variable o nombre solo puede tener un valor. Puse variable o nombre dado que los nombres a menudo se denominan "variables", pero no varían. ¡Las variables son constantes!

    n = 1 

    x = 3 * n 

    n = x   -- Error: solo puede tener una definición de n

Una vez que le da un valor a un nombre, ¡nunca podrá cambiarlo! Esto es parte del significado de "puro" y "sin efectos secundarios"

¿Qué pasa con n = n + 1? En lenguajes imperativos, frecuentemente decimos n: = n + 1. Pero esto es una tarea, no una ecuación

En Haskell, es válido escribir n = n + 1. Pero Haskell lo intentará y fallará. Dado que tratará de resolver n con n de forma recursiva. 

Pero como se puede vivir sin asignaciones? Pensemos en una declaración de asignación como si hiciera tres cosas:

• Evalúa el lado derecho: calcula un valor útil.
• Descarta el valor de la variable del lado izquierdo: destruye un valor que podría ser útil o no.
• Guarda el valor útil del RHS en la variable.

En un lenguaje puramente funcional, nunca destruimos los viejos valores. Simplemente calculamos nuevos útiles. Si el valor anterior era realmente inútil, el recolector de basura reclamará su almacenamiento.

Lambdas en Python

Las lambdas son funciones que se definan al vuelo y no tienen nombre, se conocen como funciones anónimas en algunos otros lenguajes. Es posible que desee utilizar lambdas cuando no desee utilizar una función dos veces en un programa. Son como funciones normales e incluso se comportan como ellas. Por ejemplo: 

add = lambda x, y: x + y

print(add(3, 5))

# Output: 8

Podemos utilizar para indicar como ordenar nuestras listas :

a = [(1, 2), (4, 1), (9, 10), (13, -3)]

a.sort(key=lambda x: x[1])

print(a)

# Output: [(13, -3), (4, 1), (1, 2), (9, 10)]

Y podemos ordenar listas concurrentemente: 

data = zip(list1, list2)

data = sorted(data)

list1, list2 = map(lambda t: list(t), zip(*data))

Elementos básicos en Haskell

Expresiones: En casi todos los lenguajes de programación puedes crear expresiones como:

    (b * b-4 * a * c) / 2 * a

y puede asignar estas expresiones a variables:

  v = (b*b-4*a*c)/2*a

En Haskell, también puede hacer esto, y lo que es más: las expresiones son realmente todo lo que hay, no hay declaraciones.

Funciones: En Python, puede definir una función como

    def hello(name):

        return "Hello, "+name

En Haskell puedes escribir esto simplemente como:

   hello name = "Hello, "++name

Tipos : C tiene tipos, por ejemplo:

    int f (int x, int y) {

        return x*y+x+y;

    }

Haskell tiene tipos mucho más poderosos que C, y se definen en una linea diferente de la función :

    f :: Int -> Int -> Int

    f x y =  x*y+x+y

Listas : En muchos lenguajes, p. Ej. Python, JavaScript, Ruby,… puedes crear listas como:

    lst = ["A", "lista", "de", "cadenas"]

Haskell también usa esta sintaxis para listas.

Para unirse a listas, en Python puede escribir

    lst = [1,2] + [3,4]

En Haskell esto sería muy similar:

    lst = [1,2] ++ [3,4]

Funciones anónimas : En JavaScript puede definir funciones anónimas (funciones sin nombre) como:

var f = function (x, y) {return x * y + x + y};

En Haskell, estas funciones anónimas se denominan funciones lambda y en realidad son la base del lenguaje. Nuevamente, la sintaxis es muy compacta:

f = \x y -> x*y+x+y

\ representa el símbolo lambda. 

Funciones de orden superior : Finalmente, en muchos lengujes, las funciones pueden operar sobre funciones. Por ejemplo, en Perl puede modificar los elementos en una lista usando:

    map sub ($x){$x*2+1}, [1..10]

Haskell proporciona muchas de las llamadas funciones de orden superior y le permite definir las suyas propias.

    map (\x -> x*2+1) [1..10]

Como puedo obtener el número actual de conexiones en una base de datos PostgreSQL??

SELECT sum(numbackends) FROM pg_stat_database;

Y Listo!! Con esta query se cuantas conexiones hay en mi base de datos. 

Libros Gratuitos de Java Code Geeks

 

Download IT Guides!   Docker Containerization Cookbook Docker is the world's leading software containerization platform. Docker containers wrap a piece of software in a complete filesystem that contains everything needed to run: code,...     Git Tutorial Git is, without any doubt, the most popular version control system. Ironically, there are other version control systems easier to learn and to use, but, despite that, Git is the favorite...     Spring Framework Cookbook The Spring Framework is an open-source application framework and inversion of control container for the Java platform. The framework's core features can be used by any Java application,...     Apache Hadoop Cookbook Apache Hadoop is an open-source software framework written in Java for distributed storage and distributed processing of very large data sets on computer clusters built from commodity...

Por qué GraalVM?

Lo único malo que veo en GraslVM es el marketing que están llevando. Dado que GraalVM es un proyecto paraguas donde hay varios proyectos. Entre los que tenemos una maquina virtual más rápida, la capacidad de compilar nuestras aplicaciones de forma nativa o diferentes plataformas o ejecutar varios lenguajes. 

Lo que hace que cuando hablemos de GraalVM, estemos hablando de cosas diferentes, todo a la vez. 

GraalVM es un maquina virtual java de alto rendimiento que proporciona mejoras significativas en el rendimiento y la eficiencia de la aplicación, lo que es ideal para microservicios. Está diseñado para aplicaciones escritas en Java, JavaScript, lenguajes basados ​​en LLVM como C y C++, y otros lenguajes dinámicos. Elimina el aislamiento entre lenguajes de programación y habilita la interoperabilidad en un tiempo de ejecución compartido. Puede ejecutarse de forma independiente o en el contexto de OpenJDK, Node.js u Oracle Database.

Para las aplicaciones Java existentes, GraalVM puede proporcionar beneficios al ejecutarlas más rápido, brindar extensibilidad a través de lenguajes de secuencias de comandos o crear imágenes nativas compiladas.

GraalVM se puede ejecutar en el contexto de OpenJDK para hacer que las aplicaciones Java se ejecuten más rápido con una nueva tecnología de compilación jit. GraalVM se hace cargo de la compilación del byte code de Java en código de máquina. En particular, para otros lenguajes basados ​​en JVM como Scala, esta configuración puede lograr beneficios, como por ejemplo, lo experimentó Twitter al ejecutar GraalVM en producción.

GraalVM permite ejecutar JavaScript, R, Python, Ruby, LLVM IR y Web Assembly en el contexto de aplicaciones Java. Ofrece la capacidad de exponer las estructuras de datos de Java a esos lenguajes con filtros de acceso de host detallados. La integración es independiente del lenguaje, es decir, una integración para JavaScript también se puede utilizar en un punto posterior para ejecutar cualquier otro lenguaje basado en GraalVM. Los mecanismos de proxy permiten simular objetos dinámicos de estructuras de datos Java y exponerlos a los scripts integrados. 

La ejecución de su aplicación dentro de una máquina virtual Java conlleva costos de inicio y de espacio. GraalVM tiene una función para crear imágenes nativas para aplicaciones existentes basadas en JVM. El proceso de generación de imágenes emplea análisis estático para encontrar cualquier código accesible desde el método principal de Java y luego realiza una compilación completa con anticipación (AOT). El binario nativo resultante contiene todo el programa en forma de código máquina para su ejecución inmediata. Se puede vincular con otros programas nativos y, opcionalmente, puede incluir el compilador GraalVM para soporte de compilación complementaria Just-In-Time (JIT) para ejecutar cualquier lenguaje basado en GraalVM con alto rendimiento. Para obtener un rendimiento adicional, se pueden crear imágenes nativas con optimizaciones guiadas por perfiles recopiladas en una ejecución anterior de la aplicación. Vea un ejemplo de cómo crear imágenes nativas aquí.

GraalVM puede ejecutarse en el contexto de Node.js reemplazando V8 con GraalVM para ejecutar JavaScript. Los principales beneficios de hacerlo es habilitar aplicaciones políglotas (por ejemplo, usar bibliotecas Java, R o Python), ejecutar Node.js con configuraciones de montón grandes y recolectores de basura de Java, o usar la interoperabilidad de GraalVM para definir estructuras de datos en C / C ++ y utilícelos desde JavaScript.

GraalVM permite el uso de bibliotecas Java existentes o frameworks Java (como Spark o Flink) directamente desde Node.js. Además, se puede usar, por ejemplo, R o Python para ciencia de datos o trazar directamente desde una aplicación JavaScript.

El motor de JavaScript V8 incluido en la distribución estándar de Node.js está optimizado para las configuraciones del navegador y diseñado para funcionar de manera efectiva en escenarios de almacenamiento pequeño. Habilitamos la ejecución de Node.js con la gestión de montón de la JVM, lo que abre la posibilidad de configuraciones de montón grandes y configuraciones adecuadas de recolección de basura. El tamaño máximo de pila configurable es de 32 Gb con punteros comprimidos de 32 bits, y se admiten terabytes de pila en la configuración de puntero de 64 bits.

GraalVM permite una combinación eficiente de código nativo (por ejemplo, escrito en C / C ++) y JavaScript. Se puede acceder directamente a las estructuras de datos nativas y el compilador puede integrarse a través de cualquier límite. Esto puede ser beneficioso en un escenario donde las estructuras de datos eficientes se administran y asignan en C mientras que otras partes de la aplicación están escritas en Node.js. 

Ruby, R, Python, WebAssembly son experimentales en el ecosistema GraalVM y no se recomiendan para uso de producción en este momento, pero estamos trabajando activamente en la estabilidad y el soporte para todos los módulos para esos lenguajes. En este momento, podemos ejecutar aplicaciones más simples de Ruby, R y Python, pero no tenemos la misma compatibilidad total que proporcionamos para las aplicaciones Java y Node.js. WebAssembly actualmente implementa la especificación WebAssembly MVP (producto mínimo viable) y es el lenguaje más reciente en el entorno GraalVM.

Además de los beneficios estándar de GraalVM, como la interoperabilidad de idiomas (por ejemplo, usar Java o JavaScript desde esas aplicaciones), GraalVM puede lograr altas velocidades de 10 veces o más para esos idiomas. Nos complace ayudarlo a hacer que las aplicaciones Ruby y R existentes funcionen con GraalVM, pero todavía no podemos garantizar la compatibilidad inmediata para estos idiomas.

GraalVM está diseñado para integrarse y se puede ejecutar en bases de datos. El prototipo de Oracle Database Multilingual Engine (MLE) está disponible. Permite a los usuarios de Oracle Database ejecutar JavaScript, utilizando browserify para ejecutar módulos Node.js y escribir extensiones en Python.

GraalVM Native Image, actualmente disponible como tecnología de pioneros, funciona con muchos marcos de microservicios Java diferentes. Varios proyectos ya han aceptado esta tecnología como plataforma para sus aplicaciones: Quarkus, Micronaut, Helidon. Para estos marcos, las imágenes nativas de GraalVM reducen significativamente los requisitos de memoria en tiempo de ejecución en comparación con la ejecución en HotSpot. Creemos que la tecnología GraalVM Native Image puede convertirse en la mejor manera de implementar aplicaciones nativas en la nube.

Fomentamos el desarrollo de incrustaciones de GraalVM similares a nuestras propias integraciones en Oracle Database, OpenJDK o Node.js. Junto con socios de colaboración de investigación, ya exploramos ideas de incrustación en Spark o Flink. Encuentre una descripción sobre cómo incrustar GraalVM en su aplicación nativa o basada en JVM existente aquí.

GraalVM es un ecosistema abierto e invitamos a los sistemas de terceros a participar conectando sus propios lenguajes de programación, herramientas o plataformas.

El marco de implementación de Truffle Language permite ejecutar lenguajes de programación de manera eficiente en GraalVM. Simplifica la implementación del lenguaje al derivar automáticamente código de alto rendimiento de los intérpretes. Puede encontrar detalles sobre el enfoque en este artículo de investigación.

Implementar su propio lenguaje usando GraalVM no solo le dará un alto rendimiento. Más importante aún, permite que su lenguaje se conecte con las herramientas enriquecidas proporcionadas por el ecosistema GraalVM. Además, permite que su lenguaje se ejecute en el contexto de cualquier incrustación de GraalVM.

Se Desarrollao un lenguaje de demostración llamado "SimpleLanguage" para mostrar el uso del marco de implementación del lenguaje de GraalVM. 

GraalVM proporciona un marco para crear herramientas independientes del lenguaje como depuradores, perfiladores u otras instrumentaciones. GraalVM proporciona una forma estandarizada de expresar y ejecutar código de programa que permite la investigación en varios idiomas y el desarrollo de herramientas que se desarrollan una vez y luego se pueden aplicar a cualquier idioma.

Dejo link: 

https://www.graalvm.org/docs/why-graal/

Las Coroutines en python

El nombre Coroutines me suenan a go, será por las goroutines? Bueno, pero veamos como funciona esto en python. 

Las corrutinas son similares a los generadores con algunas diferencias. Las principales diferencias son:

• los generadores son productores de datos
• las corrutinas son consumidores de datos

En primer lugar, revisemos el proceso de creación del generador. Podemos hacer generadores como este:

def fib():

    a, b = 0, 1

    while True:

        yield a

        a, b = b, a+b

Luego lo usamos comúnmente en un bucle for como este:

for i in fib():

    print(i)

 Las corrutinas consumen valores que se le envían. Un ejemplo muy básico sería una alternativa grep en Python:

def grep(pattern):

    print("Searching for", pattern)

    while True:

        line = (yield)

        if pattern in line:

            print(line)

yield en este caso no contiene ningún valor, sino que le proporcionamos valores externamente. Suministramos valores mediante el método .send(). Aquí hay un ejemplo:

search = grep('coroutine')

next(search)

# Output: Searching for coroutine

search.send("I love you")

search.send("Don't you love me?")

search.send("I love coroutines instead!")

# Output: I love coroutines instead!

Es necesario para iniciar la corrutina, correr next. Al igual que los generadores, las corrutinas no inician la función de inmediato. En su lugar, lo ejecutan en respuesta a los métodos __next __ () y .send (). Por lo tanto, debe ejecutar next () para que la ejecución avance a la expresión yield.

Podemos cerrar una corrutina llamando al método .close ():

search = grep('coroutine')

# ...

search.close()

Y listo!!

Dejo link: https://book.pythontips.com/en/latest/coroutines.html

Singleton Anti-Pattern

Singleton es un patrón muy muy enseñado, y creo que es solo porque es fácil de implementar. 

Pero este patrón nació en entornos no concurrentes y en procesos de desarrollo que no se utilizaba unit test. Por lo tanto, en ese entorno era bueno, pero el tiempo ha pasado y cada vez más todos los entornos son concurrentes y es imprescindible tener unit test en nuestro software. Lo que ha convertido al amigo Singleton en un Anti-Pattern. 

Por que no deberíamos utilizar Singleton: 

• Que es singleton: El mayor problema con el patrón singleton (y por qué es, por lo tanto, un antipatrón de diseño en lugar de un patrón de diseño) es que la suposición de que alguna vez habrá solo una instancia a menudo se rompe durante la vida útil de un proyecto, y este patrón se estructura el código de una manera que requiere un esfuerzo muy significativo para refactorizar cuando esta suposición es inevitablemente incorrecta. Es decir, muchos casos demuestran la necesidad de garantizar que el código sea flexible en caso de que la suposición de unicidad resulte falsa, y este patrón hace que el código sea inflexible.
• Dificulta las pruebas: Además de hacer que el código sea inflexible, el patrón singleton también dificulta mucho la prueba del código. Esto se debe a que el patrón singleton introduce una dependencia a través de un canal lateral que no se da explícitamente como parámetro a los constructores u otras funciones que lo utilizan. Incluso en el caso de que este canal lateral pueda ser reemplazado (y a menudo hacerlo es muy difícil), la necesidad de hacerlo es menos obvia y hace que las pruebas sean muy difíciles de entender. El otro problema es que se muy difícil de hacer un mock de este objeto. 
• No es seguro a nivel de hilos o es un cuello de botella: Incluso ignorando los problemas anteriores (que son, creo, las razones más fuertes para evitar este patrón), el patrón singleton es especialmente difícil de implementar correctamente cuando se tiene en cuenta el subproceso múltiple. la aplicación requiere que el objeto singleton, en sí mismo, sea seguro para subprocesos; sin embargo, mover la propiedad singleton fuera del objeto permite crear implementaciones alternativas, algunas de las cuales son seguras para subprocesos y otras que no lo son, lo que permite a las aplicaciones que no son multiproceso crear instancias de una versión del objeto que no tiene la sobrecarga de la sincronización de subprocesos al tiempo que permite que las aplicaciones multiproceso creen una instancia de la versión segura para subprocesos.

Si tienen más curiosidad dejo link: https://www.michaelsafyan.com/tech/design/patterns/singleton

Corre Groovy en tu browser con Grooscript

Si existe Scala.js por que no puede existir un Groovy que corra en el browser. Y existe y se llama Grooscript. 

Grooscript es todo lo que has soñado y si no lo soñaste te cuento. Este es un lenguaje muy similar a groovy que compila a javascript. 

Y se puede utilizar en framework como node, veamos un ejemplo: 

//DSL using Node.js with Express

server {
    get('/') {
        render 'Hello World!'
    }
    get('/spanish') {
        render 'Hola Mundo!'
    }
    get('/salute/:name') {
        render "Hello ${req.params.name}!"
    }
}.start(3000)

Para poder utilizarlo debemos instalar node y groovy y luego instalar con npm grooscript : 

> npm install grooscript

Luego de instalada podemos crear nuestros archivos groovy, por ejemplo : 

class Hello {

  def methodMissing(String name, args) {

    println "Hello ${name}!"

  }

}

def hello = new Hello()

hello.Groovy()

hello.Javascript()

hello.grooscript()

Luego tenemos que compilar este script groovy a javascript : 

 @Grab('org.grooscript:grooscript:1.2.2')

import org.grooscript.GrooScript

def conversionOptions = [:]

conversionOptions['initialText'] = "var gs = require('grooscript');"

GrooScript.convert 'source.groovy', '.', conversionOptions

luego con este último script, compilamos el script inicial de la siguiente forma : 

groovy convert.groovy

con este paso obtenemos el source.js, que podemos ejecutarlo así  : 

> node source.js

Hello Groovy!

Hello Javascript!

Hello grooscript!

Y listo, se ve que esta tecnología esta en pañales pero agárrate typescript!!

for/else de python

Hay muchas cosas que no sé y llego tarde, una es esta. Existe en python el for/else. 

Como es esto? La cláusula else se ejecuta después de que el ciclo se completa normalmente. Esto significa que el bucle no encontró una declaración de interrupción o break.

Por ejemplo : 

 for item in container:

    if search_something(item):

        # Found it!

        process(item)

        break

else:

    # Didn't find anything..

    not_found_in_container()

Esto nos libra de tener una variable bandera para saber si salio del for por el break o porque completo el for. Muy útil, muy fácil, y listo!

Rosetta code

Encontré una pagina, que hace siglos que esta en Internet pero yo no la había visto antes, y como para mi es noticia. La quiero compartir con ustedes. 

Es una pagina donde hay código de muchos lenguajes, casi todos.  La idea es presentar soluciones a la misma tarea en tantos lenguajes diferentes como sea posible, demostrando cómo los lenguajes son similares y diferentes, y ayudar a una persona con una base en un enfoque de un problema para aprender otro. Rosetta Code tiene actualmente 1.067 tareas, 206 borradores de tareas y 800 lenguajes.

Dejo link: http://www.rosettacode.org/wiki/Rosetta_Code

Utilizar valores implícitos atenta contra la legibilidad del código?

El Zen de Python dice : Explicit is better than implicit o Explícito es mejor que implícito. Cosa que me ha dejado pensando porque no aplica siempre. Por ejemplo: 

boolean b;

if (b == true) then: ...

b por defecto es false, pero no se lo estamos diciendo, en este caso yo particularmente prefiero ser explicito, es decir dejar claro cual es el valor de la variable: 

boolean b = false

pero me choca y me disgusta (es que ya estoy viejo) el if , es como que el programador no tiene en cuenta que b es un dato. Y ese dato lo podemos comprobar, prefiero: 

if (b) then: ...

Pero hay cosas implicitas en los lenguajes que a mi modo de ver las cosas, atentan contra la legibilidad. 

El caso más fácil de ejemplificar es que valores de otros tipos sean false o true, eso hace más fácil a vida del experto pero sin duda no deja tan clara las cosas. Por ejemplo: 

if (typeof(some_variable) != 'undefined' && some_variable != null)

{

    // Do something with some_variable

}

por : 

if (some_variable)

{

    // Do something with some_variable

}

Claro que la ultima es más corto, pero que diablos hace? Si sabes javascript es fácil, pero lo puede entender todo el mundo? 

Que opinan?

Feliz Día!!

Dice la wikipedia: El Día de los Programadores es un día festivo profesional oficial en algunos países del mundo.[¿cuál?] Se celebra el 256º día de cada año (13 de septiembre durante los años normales y el 12 de septiembre durante los bisiestos)

Por lo tanto, Feliz día!!!!

Libros gratuitos de Java Code Geeks

 

Download IT Guides!   Microservices for Java Developers Microservices are a software development technique – a variant of the service-oriented architecture (SOA) structural style – that arranges an application as a collection of loosely...     JMeter Tutorial JMeter is an application that offers several possibilities to configure and execute load, performance and stress tests using different technologies and protocols. It allows simulating...     Java Design Patterns A design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be...     Elasticsearch Tutorial Elasticsearch is a search engine based on Lucene. It provides a distributed, multitenant-capable full-text search engine with an HTTP web interface and schema-free JSON documents....