sábado, 27 de junio de 2020

Unión de tipos en Typescript


La unión de tipos están estrechamente relacionados con la intersección de tipos, pero se usan de manera muy diferente. Ocasionalmente,nos encontraremos con una librería que espera que un parámetro sea un número o una cadena. Por ejemplo, la siguiente función:

/**
 * Takes a string and adds "padding" to the left.
 * If 'padding' is a string, then 'padding' is appended to the left side.
 * If 'padding' is a number, then that number of spaces is added to the left side.
 */
function padLeft(value: string, padding: any) {
    if (typeof padding === "number") {
        return Array(padding + 1).join(" ") + value;
    }
    if (typeof padding === "string") {
        return padding + value;
    }
    throw new Error(`Expected string or number, got '${padding}'.`);
}

padLeft("Hello world", 4); // returns "    Hello world"

Al tipar padding como any no estamos utilizando las ventajas del lenguaje de tipado estático y corremos el riesgo que se lance el error dado que han utilizado dicha función con otro tipo. 

En lugar de any, podemos usar un tipo de unión para el parámetro:

/**
 * Takes a string and adds "padding" to the left.
 * If 'padding' is a string, then 'padding' is appended to the left side.
 * If 'padding' is a number, then that number of spaces is added to the left side.
 */
function padLeft(value: string, padding: string | number) {
    // ...
}

let indentedString = padLeft("Hello world", true); // esto no compila

Un tipo de unión describe un valor que puede ser uno de varios tipos. Usamos la barra vertical (|) para separar cada tipo, por lo tanto string | number es el tipo de valor y que puede ser un número o una cadena.

Si tenemos un valor que tiene un tipo de unión, solo podemos acceder a los miembros que son comunes a todos los tipos de la unión.

La diferencia con la intersección es que este parámetro puede ser uno o el otro tipo. Pero en la intersección debe ser los dos, es un y. 

Dejo link : 
https://www.typescriptlang.org/docs/handbook/advanced-types.html#union-types

jueves, 25 de junio de 2020

Intersección de tipos en Typescript

Poco he hablado de Typescript, la verdad que fruto de mi ignorancia, no me llamo la atención este lenguaje y me parecia que aportaba poco o nada al mundo de los lenguajes. Y me equivoque feo.

Typescript tiene un conjunto de características por demás interesantes, que voy a ver en este post y en una serie de post que voy a escribir (si no me aburro) 

Ahora vamos a hablar de Intersección de tipos en Typescript.

Un tipo de intersección combina múltiples tipos en uno. Esto le permite agregar tipos existentes para obtener un solo tipo que tenga todas las características que necesita. Por ejemplo, Person & Serializable & Loggable es Person, Serializable y Loggable. Eso significa que un objeto de este tipo tendrá todos los miembros de los tres tipos.

Los tipos de intersección son utilizados mayormente para mixins y otros conceptos que no encajan en el molde clásico orientado a objetos. (¡Hay muchos de estos en JavaScript!) Aquí hay un ejemplo simple que muestra cómo crear un mixin:

function extend<First, Second>(first: First, second: Second): First & Second {
    const result: Partial<First & Second> = {};
    for (const prop in first) {
        if (first.hasOwnProperty(prop)) {
            (result as First)[prop] = first[prop];
        }
    }
    for (const prop in second) {
        if (second.hasOwnProperty(prop)) {
            (result as Second)[prop] = second[prop];
        }
    }
    return result as First & Second;
}

class Person {
    constructor(public name: string) { }
}

interface Loggable {
    log(name: string): void;
}

class ConsoleLogger implements Loggable {
    log(name) {
        console.log(`Hello, I'm ${name}.`);
    }
}

const jim = extend(new Person('Jim'), ConsoleLogger.prototype);
jim.log(jim.name);

Puff, super potente!!  

C# 9 viene con mejoras en la inferencia de tipos


Al parecer C# 9 viene con un montón de mejoras, muchas pero una que me llamo la atención es una nueva forma de inferir datos. En realidad no sé si lo esta infiriendo, solamente no lo escribis 2 veces. 

Básicamente es lo opuesto a la palabra clave var. En lugar de omitir el nombre de tipo en la declaración de variable, omite el nombre de tipo en el lado de creación de valor. Veamos un ejemplo:

private Dictionary<string, List<int>> field = new Dictionary<string, List<int>>();
private Dictionary<string, List<int>> field = new(); //Esta es la forma nueva

XmlReader.Create(reader, new XmlReaderSettings() { IgnoreWhitespace = true });
XmlReader.Create(reader, new() { IgnoreWhitespace = true }); //Esta es la forma nueva

Desde la perspectiva del desarrollador, eso es casi todo lo que hay que hacer. La característica elimina el tipo en situaciones en las que es redundante o simplemente no es interesante. Pero desde la perspectiva del diseño del lenguaje hay numerosos temas a considerar.

Por ejemplo, ¿qué debería ocurrir si hay dos sobrecargas viables? ¿Debería el compilador elegir la "mejor" coincidencia, o marcarla como un error ambiguo como lo hace para dos sobrecargas que difieren solo en el tipo de un parámetro de salida?

Según las notas de LDM, Microsoft eligió este último. Parte de la razón es hacer que agregar nuevas sobrecargas sea menos probable que resulte en un cambio radical. Tenga en cuenta la frase "menos probable", ya que este tipo de inferencia de tipo siempre será susceptible a problemas causados ​​por sobrecargas adicionales.

Un problema de diseño de lenguaje común es determinar cuándo filtrar sobrecargas inapropiadas. En el pasado ha habido casos en los que el compilador elegía una sobrecarga, solo para luego emitir un error del compilador porque violaba una restricción de parámetro genérico. Esto se conoce como un "enfoque de filtro tardío" y, aunque simplifica el diseño del compilador, reduce las posibilidades de que el compilador encuentre con éxito una sobrecarga en un fragmento de código arbitrario.

En cambio, un "enfoque de filtro temprano" intentaría eliminar tantas sobrecargas como sea posible antes de elegir una. Nuevamente, esto aumenta la complejidad del compilador a cambio de tener más probabilidades de encontrar una buena coincidencia. 


martes, 23 de junio de 2020

Rust llega a los 20 lenguajes de programación más populares de TIOBE

Toma tu torta!! 
Rust un lenguaje muy joven llego a los 20 lenguajes más populares según TIOBE. 

El índice TIOBE es una medida de más larga data de la popularidad del lenguaje de programación en el uso en el mundo real. Los cinco principales lenguajes son C, Java, Python, C++ y C#. Rust es un competidor directo de C y C++ y, en menor medida, un competidor de Java y C#. Y ya entro en carrera, esperemos que siga subiendo. 

lunes, 22 de junio de 2020

AdoptOpenJDK se convierte en Eclipse Adoptium

Una de las JDK más utilizadas, cambia de nombre para estar bajo el paraguas de la organización eclipse.

El comité que se ocupa de los planes de AdoptOpenJDK, confirmó en una publicación que habían acordado la medida con la Fundación Eclipse. 

La misión del Proyecto Eclipse Adoptium es producir una JDK de alta calidad y tecnología asociada para su uso dentro del ecosistema de Java. Logrando esto a través de un conjunto de proyectos bajo Adoptium PMC y una estrecha asociación de trabajo con proyectos externos, especialmente OpenJDK para proporcionar la implementación de tiempo de ejecución Java SE. El proyecto Eclipse Adoptium es la continuación de la misión original AdoptOpenJDK.

sábado, 20 de junio de 2020

Value Class en Scala

El objetivo de Value Class es para que Scala ofrezca una sintaxis que tenga cero overhead comparado con los métodos externos. Cuando lo podemos usar?

Puede ser muy práctico para nuestro código, no pensar en un valor propiamente dicho, sino en un wrapper que nos de más flexibilidad. Por ejemplo, en la aplicación que estamos trabajando se utiliza pesos pero en vez de modelarlo como un Double, utilizo un wrapper (que va ser una clase valor o value class) de esta forma no penalizo la performance (ya van a ver porque digo esto) y si en el futuro desean trabajar con otras monedas, dolares, por ejemplo me va a costar mucho menos el cambio gracias a este wrapper.

Value Class son un mecanismo en Scala que ayuda a evitar la asignación de objetos en tiempo de ejecución. Esto se logra a través de la definición de nuevas subclases de AnyVal. A continuación se muestra una definición de clase de valor muy mínima:

case class UserId(val id: Int) extends AnyVal

Como puede ver una clase de valor, debe tener exactamente un parámetro y no tener nada dentro, excepto defs. Además, ninguna otra clase puede extender una clase de valor, y una clase de valor no puede redefinir equals o hashCode. 

Fundamentalmente, una clase de valor es aquella que se ajusta a un tipo muy simple o un valor simple, como Int, Boolean, etc. Lo que eso significa es que, en el momento de la compilación, ve la clase de valor y usa la clase de valor, pero se genera un byte code, que en realidad está utilizando el tipo simple. Entonces, eso aumentan el rendimiento y crean menos uso de memoria, porque no hay una instancia de las clases contenedoras.

Las clases de valor se utilizan principalmente para la optimización del rendimiento y la optimización de la memoria. Puede pensar en muchas de estas clases como su primitiva típica de Scala, como las clases Int, Boolean, Double, etc. Los casos de uso en los que desearía y donde podría aplicar clases de valor son para tipos pequeños. 

miércoles, 17 de junio de 2020

Libros de Java Geeks

 

Apache ActiveMQ Cookbook

Apache ActiveMQ is an open source message broker written in Java together with a full Java Message Service (JMS) client. It provides “Enterprise Features” which means fostering the...

 
 

JDBC Tutorial

JDBC (Java Database Connectivity) is an API provided by Oracle that allows programmers to handle different databases from Java applications: it allows developers to establish connections...

 
 

JSF 2.0 Programming Cookbook

JavaServer Faces (JSF) is a Java specification for building component-based user interfaces for web applications. JSF 2 uses Facelets as its default templating system. Other view...

 
 

Developing Modern Applications with Scala

Scala is a general-purpose programming language. It has full support for functional programming and a very strong static type system. Designed to be concise, many of Scala's design...

 

Análisis de texto usando funciones de orden superior

El análisis es el mecanismo que utilizamos para dar sentido a la información estructurada en un texto, por ejemplo lenguaje escrito o hablado. En el caso del lenguaje escrito, implica varios pasos:
  • reconociendo los caracteres del sistema de escritura,
  • palabras identificativas,
  • identificar oraciones,
  • identificar párrafos, etc.

Para poder hacerlo, necesitamos conocer el sistema de escritura, la ortografía y la gramática del idioma en el que está escrito el documento.

Para analizar texto estructurado como el código fuente del programa, HTML o JSON, el problema es similar.

Hasta ahora, hemos visto funciones que toman funciones como argumentos. Las funciones también pueden devolver funciones como valores
Por ejemplo, aplicación parcial de una función:

sum = foldl (+) 0

Aquí (suma) es el resultado devuelto por la aplicación parcial de (foldl).

Más explícitamente, podemos escribir esto como:

sum = \xs -> foldl (+) 0 xs

Ambos son, por supuesto, la misma cosa, solo diferentes interpretaciones.

Podemos usar este concepto para generar funciones parametrizadas
Por ejemplo, la siguiente función genera funciones que agregan un número constante a su argumento:

gen_add_n = \n ->
    \x -> x+n

add_3 = gen_add_n 3
add_7 = gen_add_n 7

add_3 5 --> 8
add_7 4 --> 11

Por supuesto, esto no se limita a las constantes numéricas
Por ejemplo, la siguiente función genera funciones que realizan una operación aritmética dada en un número constante y su argumento:

gen_op_n = \op n ->
    \x -> x `op` n

add_3 = gen_op_n (+) 3
mult_7 = gen_op_n (*) 7

add_3 5 --> 8
mult_7 4 --> 28

Para hacer que el problema de análisis sea más concreto, suponga que debe analizar la siguiente receta e identificar los diferentes pasos necesarios en la preparación.

Hervir una olla grande de agua. A diferencia de la pasta italiana, no es necesario salar el agua. Una vez que esté hirviendo, sostenga los fideos sobre el agua y espolvoréelos hilo por mechón. Una vez que todos los fideos estén adentro, revuelva suavemente para que estén todos sumergidos en el agua. Vuelva a hervir suavemente el agua y luego baje el fuego para que el agua hierva a fuego lento. (Esto difiere del 'hervor rodante' que se recomienda para la pasta). Si el agua amenaza con hervir, agregue aproximadamente 1/2 taza de agua fría (pero si baja el fuego a fuego lento y tenga una olla lo suficientemente grande) , esto no debería ser necesario). Cocine durante aproximadamente 7 a 8 minutos, o siguiendo las instrucciones del paquete (para fideos más delgados, de 5 a 6 minutos puede ser suficiente. Pruebe comiendo un mechón; debe cocinarse bien, no al dente, pero tampoco blanda).
Típicamente, un programa funcional se organiza alrededor de una estructura de datos en forma de árbol con un tipo de datos algebraicos que representa los datos centrales.Un analizador lee la entrada de texto y genera el árbol. Las funciones realizan transformaciones o recorridos en el árbol.
La función Show imprimen el árbol (original o transformado)

Los combinadores de analizador son funciones que le permiten combinar analizadores más pequeños en otros más grandes. Son funciones de orden superior que toman funciones como argumentos y devuelven funciones. Una biblioteca de combinador de analizador proporciona analizadores básicos (para palabras, números, etc.) y combinadores.

Parsec: combinadores de análisis monádico Hay muchas bibliotecas de análisis para Haskell. Parsec opera en una mónada.

Es posible que haya escuchado el término mónada antes, y discutiremos el concepto en detalle en una sesión posterior. Haskell usa mónadas para estructurar cálculos. Ya te has encontrado con la mónada IO, que debes usar para realizar IO en un programa Haskell. Un ejemplo típico es

hello :: String -> IO String
hello x =
  do
     putStrLn ("Hello, " ++ x)
     putStrLn "What's your name?"
     name <- getLine
     return name

Esto ilustra las características sintácticas clave de una mónada: la palabra clave do, la secuencia de comandos, la forma de extraer información de un cálculo monádico utilizando la flecha izquierda <- y la palabra clave return. De hecho, el uso de la notación do es bastante similar a la programación imperativa.

También tenga en cuenta el valor de retorno de nuestra función hello: no solo String sino IO String. Un cálculo realizado en una mónada devuelve un tipo "monádico", decimos que la cadena se devuelve dentro de la mónada.

Por ejemplo, supongamos que queremos analizar una cadena de la forma (<etiqueta>), donde (etiqueta) debe ser una palabra, y devolver la etiqueta como un tipo (Etiqueta).

data Tag = MkTag String

parseTag :: Parser Tag
parseTag =
  do  char '<'
      x <- identifier
      char '>'
      return (MkTag x)

Como puede ver, el analizador consta de una serie de funciones (por ejemplo, char e identificador) que se llaman secuencialmente. Además, el valor de retorno es de tipo Parser Tag, no simplemente Tag. Esto se debe a que parseTag no devuelve un valor, sino que devuelve un analizador. Podemos combinar este analizador con otros analizadores, y luego podemos ejecutar el analizador final en nuestros datos. 


Para probar su analizador, inicie ghci:

[wim@fp4 ~]$ ghci
GHCi, version 7.4.1: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Then, import Parsec:

Prelude> import Text.ParserCombinators.Parsec

Parsec proporciona la práctica función parseTest, que toma un analizador y una cadena y la ejecuta. Intentemos ejecutar el analizador char 'b' en la cadena "contras":

Prelude Text.ParserCombinators.Parsec> parseTest (char 'b') "cons"
Loading package bytestring-0.9.2.1 ... linking ... done.
Loading package transformers-0.2.2.0 ... linking ... done.
Loading package mtl-2.0.1.0 ... linking ... done.
Loading package array-0.4.0.0 ... linking ... done.
Loading package deepseq-1.3.0.0 ... linking ... done.
Loading package text-0.11.2.0 ... linking ... done.
Loading package parsec-3.1.2 ... linking ... done.
Because the string “cons” does not contain the character ‘b’, we get a parse error:

parse error at (line 1, column 1):
unexpected 'c'
expecting 'b'Probemos con char 'c':

Prelude Text.ParserCombinators.Parsec> parseTest (char 'c') "cons"
'c'
Prelude Text.ParserCombinators.Parsec>
This time the parse succeeded.


El código real para el ejemplo parseTag requiere algunos módulos y definiciones adicionales

Como un ejemplo simple, definamos parseDiv como:

-- the "deriving Show" is needed to let `ghci` print the result
data Tag = MkTag String deriving Show 

parseDiv = do 
  string "<div>" 
  return (MkTag "div")

Para definir esta función en ghci, puede escribir esto en una línea de la siguiente manera:

let parseDiv  = do { string "<div>";return $ MkTag "div" }

Ahora podemos ejecutar este analizador utilizando la función parseTest:

Prelude Text.ParserCombinators.Parsec> parseTest parseDiv "<div>"
Loading package parsec-2.1.0.1 ... linking ... done.
MkTag "div"

Prelude Text.ParserCombinators.Parsec> parseTest parseDiv "div"
parse error at (line 1, column 1):
unexpected "d"
expecting "< "
Prelude Text.ParserCombinators.Parsec>


Todos los combinadores de analizador son funciones que devuelven funciones.
Es la función devuelta que opera en la cadena, no la función del combinador del analizador.
Los analizadores básicos ((identifier),(natural),(char)) no toman argumentos (por ejemplo (identifier)) o una o más cadenas para la parametrización (por ejemplo (char)).

char = \ch -> \str ->
      -- try to match the character ch
      -- return the result

Si la coincidencia tiene éxito, la cadena coincidente se elimina de la cadena de entrada; de lo contrario, se devuelve la cadena original, p.

char "c" "cons" -->
"c"
char "b" "cons" -->
parse error at (line 1, column 1):
unexpected "c"
expecting "b"

Los combinadores de analizador como <|> y parens toman otros analizadores como argumentos.

parens = \p ->
    \str ->
        -- first match "("
        -- perform the parse of p if "(" was found
        -- then match ")"
        -- return the result

A menudo queremos probar un analizador sintáctico; Si eso falla, intente con otro. El combinador de elección <|> proporciona esta funcionalidad.

Ejemplo: (letter_digit) coincidirá con una letra o un dígito.

letter_digit :: Parser Char
letter_digit =
  do  x <- letter <|> digit
      return x

Prelude Text.ParserCombinators.Parsec> parseTest letter_digit "b2"
"b"

Prelude Text.ParserCombinators.Parsec> parseTest letter_digit "2b"
"2"

Prelude Text.ParserCombinators.Parsec> parseTest letter_digit "*2"
parse error at (line 1, column 1):
unexpected "*"
expecting letter or digit

Supongamos que queremos hacer coincidir la bolsa o el pantano, pero nada más.

bag_bog :: Parser String
bag_bog =
  do  xs <- string "bag" <|> string "bog"
      return xs

Prelude Text.ParserCombinators.Parsec> parseTest bag_bog "bag"
"bag"

Prelude Text.ParserCombinators.Parsec> parseTest bag_bog "bug"
parse error at (line 1, column 1):
unexpected "u"
expecting "bag"
But there’s a problem!

Prelude Text.ParserCombinators.Parsec> parseTest bag_bog "bog"
parse error at (line 1, column 1):
unexpected "o"
expecting "bag"


La primera "bag" de la cadena del analizador coincidió con la b pero luego falló en la a. Ahora ha consumido el b. La segunda cadena del analizador "bog" ahora intenta hacer coincidir b contra o, lo que por supuesto falla.

try: no consuma entradas en el análisis fallido
Para permitirle analizar provisionalmente sin consumir ninguna entrada, Parsec proporciona la función try:

bag_bog_try :: Parser String
bag_bog_try =
  do  xs <- try (string "bag") <|> string "bog"
      return xs


Prelude Text.ParserCombinators.Parsec> parseTest bag_bog_try "bag"
"bag"

Prelude Text.ParserCombinators.Parsec> parseTest bag_bog_try "bug"
parse error at (line 1, column 1):
unexpected "u"
expecting "bog"

Prelude Text.ParserCombinators.Parsec> parseTest bag_bog_try "bog"
"bog"
Some parsers from the library

La biblioteca Parsec proporciona algunos analizadores pequeños que son útiles para definir los más grandes:

(char \; “?”) - (char) se aplica a un personaje y le da un analizador que coincide con ese personaje
(letter): coincide con cualquier letra
(digit): coincide con cualquier dígito
(string): coincide con una cadena de caracteres
(stringLiteral \; “xyz *”): coincide con el argumento de cadena
(many \; p): coincide con 0 o más apariciones de analizador (p)
(many1 \; p): coincide con 1 o más apariciones de analizador (p)

varname :: Parser String
varname =
  do  x <- letter
      xs <- many (letter <|> digit)
      return (x:xs)

Prelude Text.ParserCombinators.Parsec> parseTest varname "a4cc7*5"
"a4cc7"

Prelude Text.ParserCombinators.Parsec> parseTest varname "34a"
parse error at (line 1, column 1):
unexpected "3"
expecting letter

Las expresiones aritméticas son complejas de analizar debido a las reglas de precedencia y la aridad de los operadores.
Parsec proporciona soporte para el análisis de expresiones, por lo que no tiene que escribir su propio analizador de expresiones.

expr_parser :: Parser Expr
expr_parser = buildExpressionParser optable term <?> "expression"

optable =
  let
    op name assoc   =
      Infix ( do {  reservedOp name;
          return (\x y ->(Op (MkOpExpr name x y))) } ) assoc
    prefix name =
      Prefix  (
        reservedOp name >>
            return (\x->(Pref (MkPrefixOpExpr name x))) )
  in
    [ [ op "*"  AssocLeft, op "/"  AssocLeft, op "%" AssocLeft ]
    , [ op "+"  AssocLeft, op "-"  AssocLeft ], [ prefix "-" ] ]

Este ejemplo usa una sintaxis adicional de mónada: puede usar llaves y punto y coma en lugar de sangría; y el operador >> también es una forma más corta de escribir la notación do:

do
  expr1
  expr2

Se puede escribir como

expr1 >> expr2

También tenga en cuenta el uso del operador <?>, Que se utiliza para definir un mensaje de error personalizado en caso de que falle un análisis sin consumir ninguna entrada. Esta es una característica de depuración muy útil.

Parsec también tiene soporte para lenguajes de programación con un mecanismo para definir la sintaxis y las palabras clave a través de makeTokenParser.
Para casos simples, puede usar emptyDef.

import Text.ParserCombinators.Parsec.Expr
import qualified Text.ParserCombinators.Parsec.Token as P

lexer       = P.makeTokenParser emptyDef

parens          = P.parens lexer
commaSep        = P.commaSep lexer
-- and many more

lunes, 15 de junio de 2020

Tenemos Patreon!!!

Dado que mucha gente me ha pedido post y otras personas, me preguntaron como se puede ayudar. He decidido satisfacer esos requerimientos y crear una cuenta en Patreon. 

Para el que no sabe patreon, es una pagina para patrocinar cosas, en este caso el blog. Y tenes diferentes niveles de patrocinado, podes solo donar o subir de nivel y en este, pedir posts. 

La idea es que con lo donado haga cursos y pueda crear más posts.  

domingo, 14 de junio de 2020

JDBC en fibras


Continuamos desde el post de R2DBC... 

Si bien JDBC y otras tecnologías exponen API de bloqueo (principalmente debido a la espera de I/O), se está trabajando en el Project Loom. Loom presenta Fibers como una abstracción ligera que convertirá las API de bloqueo en no bloqueantes. Esto es posible mediante el cambio de pila tan pronto como una invocación golpea una API de bloqueo. Entonces, el Fiber subyacente intenta continuar en un flujo anterior que estaba usando una API de bloqueo.

El modelo de ejecución de Fiber reduce drásticamente la cantidad de hilos nativos requeridos. La consecuencia es una mejor escalabilidad y un comportamiento sin bloqueo, al descargar las llamadas de bloqueo a un ejecutor. Todo lo que necesitamos aquí es una API adecuada que permita el consumo de un JDBC sin bloqueo implementado con Fibras.

comsat-jdbc proporciona un contenedor de bloqueo de fibra de la API JDBC, para que pueda usar su conexión dentro de fibras en lugar de hilos Java normales.

¿Por qué harías eso? Debido a que las fibras son hilos livianos y puede tener muchas más fibras que hilos en su JVM. "Muchos más" significa que estamos hablando de millones frente a un puñado de miles.

Esto significa que tiene mucha más capacidad de concurrencia en su sistema para hacer otras cosas en paralelo mientras espera la ejecución de JDBC, ya sean cálculos simultáneos y/o paralelos (como el intercambio de mensajes de actores) o fibra -bloqueo de I/O (p. ej., servicio de solicitudes, invocación de microservicios, lectura de archivos a través de NIO en fibra o acceso a otras fuentes de datos habilitadas para fibra como MongoDB).

Las Fibras son una solución al problema de bloqueo de JDBC. Deberíamos hablar un poco más del proyecto Loom pero pero pero, esto es otra historia y va ha ser contada en otro post ... 

Programación reactiva + bases de datos relacionales = R2DBC


Al carecer de una API estándar y la falta de disponibilidad de controladores, un equipo de Pivotal comenzó a investigar la idea de una API relacional reactiva que sería ideal para fines de programación reactiva. Y en ese momento nació, R2DBC que significa Conectividad de base de datos relacional reactiva.

Entre las características de R2DBC podemos nombrar: 

R2DBC se basa en la especificación de Reactive Streams, que proporciona una API sin bloqueo totalmente reactiva.

Trabaja con bases de datos relacionales. A diferencia de la naturaleza bloqueante de JDBC, R2DBC le permite trabajar con bases de datos SQL utilizando una API reactiva.

Admite soluciones escalables. Con Reactive Streams, R2DBC le permite pasar del modelo clásico de "un subproceso por conexión" a un enfoque más potente y escalable.

Proporciona una especificación abierta. R2DBC es una especificación abierta y establece una interfaz de proveedor de servicios (SPI) para que los proveedores de controladores implementen y los clientes los consuman.

Actualmente existen las siguientes implementaciones : 
  • cloud-spanner-r2dbc: controlador para Google Cloud Spanner
  • jasync-sql: contenedor R2DBC para Java & Kotlin Async Database Driver para MySQL y PostgreSQL escrito en Kotlin.
  • r2dbc-h2: controlador nativo implementado para H2 como base de datos de prueba.
  • r2dbc-mariadb: controlador nativo implementado para MariaDB.
  • r2dbc-mssql: controlador nativo implementado para Microsoft SQL Server.
  • r2dbc-mysql: controlador nativo implementado para MySQL.
  • r2dbc-postgres: controlador nativo implementado para PostgreSQL.
Los estándares existentes, basados ​​en el bloqueo de I/O, cortan la programación reactiva de los usuarios de bases de datos relacionales. R2DBC especifica una nueva API para permitir código reactivo que funciona de manera eficiente con bases de datos relacionales.

R2DBC es una especificación diseñada desde cero para la programación reactiva con bases de datos SQL. Define un SPI sin bloqueo para implementadores de controladores de bases de datos y autores de bibliotecas de clientes. Los controladores R2DBC implementan completamente el protocolo de conexión de la base de datos sobre una capa de I/O sin bloqueo.

R2DBC está pensado principalmente como un SPI del controlador para ser consumido por las bibliotecas del cliente y no para ser utilizado directamente en el código de la aplicación.

R2DBC admite aplicaciones nativas en la nube que utilizan bases de datos relacionales como PostgreSQL, MySQL y otras. Los desarrolladores de aplicaciones son libres de elegir la base de datos adecuada para el trabajo sin estar limitados por las API.

Spring Data R2DBC, parte de la familia Spring Data, facilita la implementación de repositorios basados en R2DBC. Spring Data R2DBC aplica abstracciones de la familia de Spring y soporte de repositorio para R2DBC. Facilita la creación de aplicaciones basadas en Spring que utilizan tecnologías de acceso a datos relacionales en una stack de aplicaciones reactivas.

Spring Data R2DBC pretende ser conceptualmente fácil. Para lograr esto, NO ofrece almacenamiento en caché, carga diferida, escritura detrás o muchas otras características de los marcos ORM. Esto hace que Spring Data R2DBC sea un mapeador de objetos simple, limitado y con opiniones.

Spring Data R2DBC permite un enfoque funcional para interactuar con su base de datos proporcionando DatabaseClient como el punto de entrada para las aplicaciones.

Veamos un ejemplo con postgres : 

PostgresqlConnectionFactory connectionFactory = new PostgresqlConnectionFactory(PostgresqlConnectionConfiguration.builder()
.host(…)
.database(…)
.username(…)
.password(…).build());

DatabaseClient client = DatabaseClient.create(connectionFactory);

Mono<Integer> affectedRows = client.execute()
        .sql("UPDATE person SET name = 'Joe'")
        .fetch().rowsUpdated();

Flux<Person> all = client.execute()
        .sql("SELECT id, name FROM person")
        .as(Person.class)
        .fetch().all();

Otro enfoque para atacar el bloqueo de JDBC es Fibers. Fibers como una abstracción ligera que convertirá las API de bloqueo en no bloqueantes. Esto es posible mediante el cambio de pila tan pronto como una invocación ... Pero eso es otra Historia y va ha ser contada en otro post ... 

Dejo links: 

Programación reactiva y bases de datos relacionales

Hay muchas respuestas sobre qué es la programación reactiva y cómo se compara con los sistemas reactivos. La Programación Reactiva se puede ver como un modelo de programación que facilita la escalabilidad y la estabilidad mediante la creación de tuberías funcionales sin bloqueo controladas por eventos que reaccionan a la disponibilidad y procesabilidad de los recursos. La ejecución diferida, la concurrencia y la asincronía son solo una consecuencia del modelo de programación subyacente.

Los beneficios completos de la programación reactiva entran en vigencia solo si toda el stack de tecnologías es reactiva y si todos los componentes participantes (código de aplicación, contenedor de tiempo de ejecución, integraciones) respetan la ejecución diferida, las API sin bloqueo y la naturaleza de flujo de flujo de datos, básicamente siguiendo los supuestos subyacentes .

Si bien es posible llevar componentes no reactivos a una aplicación que está escrita en un estilo funcional-reactivo, el resultado neto es que los beneficios reales esperados, disminuyen. En el peor de los casos, hay poca o ninguna diferencia en el comportamiento del tiempo de ejecución. Sin embargo, la programación reactiva ayuda a mejorar la legibilidad del código.

Si observamos el ecosistema reactivo, descubriremos varios frameworks, bibliotecas e integraciones. Cada uno de ellos tiene sus puntos fuertes específicos. Muchas áreas funcionales están bien cubiertas, ya sea con un enfoque genérico o dentro del contexto de un framework reactivo particular. 

Java utiliza JDBC como tecnología principal para integrarse con bases de datos relacionales. JDBC es de naturaleza bloqueante: no hay nada sensato que se pueda hacer para mitigar la naturaleza bloqueante de JDBC. La primera idea de cómo hacer que las llamadas no se bloqueen es descargar las llamadas JDBC a un ejecutor (generalmente grupo de subprocesos). Si bien este enfoque funciona, viene con varios inconvenientes que descuidan los beneficios de un modelo de programación reactiva.

Los grupos de subprocesos requieren, no es de extrañar, subprocesos para ejecutarse. Los tiempos de ejecución reactivos suelen utilizar un número limitado de subprocesos que coinciden con el número de núcleos de CPU. Los hilos adicionales introducen gastos generales y reducen el efecto de limitación de hilos. Además, las llamadas JDBC generalmente se acumulan en una cola, y una vez que los hilos están saturados de solicitudes, el grupo se bloqueará nuevamente. Entonces, JDBC ahora no es una opción.

Hay un par de controladores independientes, como el reactive-pg-client. Estos controladores vienen con una API específica del proveedor y no son realmente adecuados para una adopción más amplia. 

Como no hay una API estándar y la falta de disponibilidad de controladores, un equipo de Pivotal comenzó a investigar la idea de una API relacional reactiva que sería ideal para fines de programación reactiva. Se les ocurrió R2DBC que significa Conectividad de base de datos relacional reactiva. Pero eso es otra Historia y va ha ser contada en otro post ... 

Dejo link: 

jueves, 11 de junio de 2020

Guards, Guards!


Haskell proporciona una notación para definir funciones basadas en valores predicados.

fx
  | predicate1 = expression1
  | predicate2 = expression2
  | predicate3 = expression3

Por ejemplo, el valor absoluto de un número es su magnitud, es decir, ignorar su signo. Podría definir una función para calcular el valor absoluto con un condicional if / then / else

absolute x = if (x<0) then (-x) else x

o con guards

absolute x
  | x<0 = -x
  | otherwise = x

Observe cómo no hay un signo igual en la primera línea de la definición de la función, pero hay un signo igual después de cada guard.

La opción por default debe ser la ultima. 

Guards son más fáciles de leer que if/then/else y más si hay más de dos resultados condicionales

Por ejemplo, piense en anotar en el deporte del golf. Para un solo hoyo, un jugador realiza varios golpes. Hay un puntaje "par" para el hoyo, que es el número esperado de golpes.

holeScore :: Int -> Int -> String
holeScore strokes par
  | strokes < par = show (par-strokes) ++ " under par"
  | strokes == par = "level par"
  | strokes > par = show(strokes-par) ++ " over par"

¿Cómo podríamos arreglar esto? Tal vez podríamos convertir la Guard final en otra cosa y también refactorizar con una cláusula where.

holeScore :: Int -> Int -> String
holeScore strokes par
  | score < 0 = show (abs score) ++ " under par"
  | score == 0 = "level par"
  | otherwise = show(score) ++ " over par"
 where score = strokes-par

Observe que la variable de puntaje definida en la cláusula where está dentro del alcance de los tres Guards.

Un valor con un tipo de datos algebraico puede tener una de varias formas diferentes, como una hoja o un nodo, en el caso de las estructuras de árbol. Por lo tanto, para procesar dicho valor necesitamos varios segmentos de código, uno para cada forma posible. La expresión de caso examina el valor y elige la cláusula correspondiente. Es como un Guard, pero selecciona en función de la forma del valor, es decir, coincide con el patrón.

Aquí hay un tipo de datos de suma para mis mascotas.

data Pet = Cat | Dog | Fish

Y así es como saludo a mis mascotas.

hello :: Pet -> String
hello x = 
  case x of
    Cat -> "meeow"
    Dog -> "woof"
    Fish -> "bubble"

Tenga en cuenta que a cada patrón le sigue una flecha y luego un valor. También tenga en cuenta que cada patrón está alineado verticalmente. ¡La sangría realmente importa en Haskell!

Bien, ahora supongamos que queremos hacer que el tipo de datos sea un poco más sofisticado. Agreguemos un loro con un nombre de tipo cadena.

data Pet = Cat | Dog | Fish | Parrot String

hello :: Pet -> String
hello x = 
  case x of
    Cat -> "meeow"
    Dog -> "woof"
    Fish -> "bubble"
    Parrot name -> "pretty " ++ name

Ahora el patrón incluye una variable, que está asociada con el valor concreto para el nombre del Parrot.

hello (Parrot "polly")

De la misma manera que hay un caso general para los Guards, podemos tener un patrón general para un caso. Es el carácter de subrayado, que significa "no me importa" o "coincide con nada"

Entonces podríamos redefinir hola como:

hello :: Pet -> String
hello x =
  case x of
    Parrot name -> "pretty " ++ name
    _ -> "grunt"


martes, 9 de junio de 2020

Datos de Erlang: números y atoms

En Erlang tenemos  diferentes tipos de datos con los que podemos calcular. Tenemos números, atoms, booleanos, tuplas, listas y tipos compuestos. Además tenemos strings y funciones. Erlang es débilmente tipado por lo tanto no estamos obligados a decir qué tipos tomará una función. Puede tomar algo de cualquier tipo.

Entonces, comencemos mirando los números. Los números en Erlang pueden ser enteros y flotantes.  Los enteros bignums son números arbitrariamente grandes, números de precisión completa solo por defecto. Entonces, por ejemplo, puedes ver una gran cantidad de potencias de diez multiplicadas juntas. Pero también tenemos floats. Podemos usar diferentes bases, escribimos números a través de una base diferente poniendo la base seguida por un hash seguido inmediatamente por el número en esa base. Entonces, si escribimos dos hash uno cero cero, obtenemos el número cuatro. Si escribimos tres hash tres cuatro, obtenemos un entero ilegal porque, por supuesto, el dígito tres, el dígito cuatro no es un número legal base tres. Tendría que consistir en los dígitos cero, uno y dos. Entonces puedes usar esas diferentes bases. En particular, podemos usar hexadecimal y octal, etc. Tenemos todos los operadores habituales. .

Entonces, si escribimos 12 div 5, obtenemos la respuesta 2. Si escribimos 12.0 div 5, obtenemos un error de excepción porque lo que hemos hecho es invocar una operación entera en flotantes. Y eso es típico de Erlang. Estamos obteniendo un error de tiempo de ejecución. Así que podríamos escribir algo así en un archivo dentro de una definición de Erlang. Solo causaría un error en tiempo de ejecución. Entonces, los números son muy parecidos a los números en otros lenguajes, excepto que tenemos bignums y podemos usar diferentes bases.

Los átomos son datos que simplemente se representan a sí mismos. Entonces, si evalúo el átomo foo, que obtengo escribiendo una cadena que comienza con una letra minúscula, la respuesta es foo. No significa nada más. No es una variable. Es simplemente un dato que dice foo. Y, en general, puedo encerrar cualquier cadena de caracteres entre comillas simples. Y eso será un átomo. Entonces los átomos simplemente se representan por sí mismos. Ahora, el único cálculo que podemos hacer con los átomos es que podemos compararlos para la igualdad.

Para poder  ver que si foo es igual a sí mismo y no es igual a 'I am an atom', podemos ordenarlos. Así que foo es mayor que el átomo  'I am an atom' , dado el ordenamiento lexicográfico basado en los códigos ASCII de los caracteres.

La otra forma de comparar Atoms en por patterns matching. 

sábado, 6 de junio de 2020

Let y where en Haskell

El alcance o Scoping es una forma de mantener sus programas ordenados. Implica limitar la región del programa en la que los nombres "existen" y se pueden usar.

En Haskell, una expresión let proporciona un alcance local. Una expresión let tiene una serie de ecuaciones que definen valores variables y una expresión final (después de la palabra clave in) que calcula un valor con esas variables en el alcance.

Aquí hay un ejemplo:

let x = 2
in x*x

Se pueden definir múltiples variables en un solo let

let x = 2
     y = 3
in x+y

Tenga en cuenta que los nombres de las variables se alinean uno debajo del otro. Esta es una buena práctica de formateo, pero también es necesaria para que Haskell interprete el código correctamente. Al igual que Python, el espacio en blanco es importante en Haskell.

A veces, en let, una de las variables puede depender de otra: en la función a continuación, los galones dependen de milespergallon:

journeycost :: Float -> Float -> Float
journeycost miles fuelcostperlitre = 
 let milespergallon = 35
     litrespergallon = 4.55
     gallons = miles/milespergallon
 in (gallons*litrespergallon*fuelcostperlitre)

Aquí hay un ejemplo geométrico:

let diameter = 2*radius
     circumference = pi*diameter
in (diameter, circumference)

Por cierto, pi es una constante definida en el "prelude" de Haskell.

Hay otra sintaxis para introducir variables locales, la cláusula where. Como hemos visto, Haskell es la navaja suiza de los lenguajes de programación: hay muchas formas de hacer las cosas.

La palabra clave where, dentro de una ecuación, proporciona definiciones para las variables que se usan en la ecuación.

Aquí hay un par de ejemplos

squareplusone :: Int -> Int
squareplusone x = xsquared + 1
 where xsquared = x*x

Tengan en cuenta que es necesaria la sangría. 

Como let, podemos tener múltiples variables dentro de una cláusula where:

cel2fahr :: Float -> Float
cel2fahr x = (x*scalingfactor) + freezingpoint
 where scalingfactor = 9.0/5.0
           freezingpoint = 32

Las variables definidas en la cláusula where se alinean una debajo de la otra.

let y where son muy similares:
  • Ambos introducen un alcance local.
  • Ambas permiten escribir cualquier cantidad de ecuaciones.
  • Ambos permiten que las ecuaciones se escriban en cualquier orden, y las variables definidas en cualquier ecuación se pueden usar ("están dentro del alcance") en las otras ecuaciones.
Sin embargo, hay algunas diferencias importantes:
  • let se puede usar en cualquier lugar donde se permita una expresión.
  • where en clasuras que no son expresiones; 
  • let se pueden usar para proporcionar algunas variables locales para una ecuación de nivel superior.

miércoles, 3 de junio de 2020

Libros Gratuitos de Java Code Geek

Download IT Guides!

 

Eclipse IDE Handbook

Eclipse is an integrated development environment (IDE) used in computer programming, and is the most widely used Java IDE. It contains a base workspace and an extensible plug-in system...

 
 

Advanced Java Tutorial

Learning the basics of Java is easy. But really delving into the language and studying its more advanced concepts and nuances is what will make you a great Java developer. The web is...

 
 

Amazon AWS Lambda Tutorial

AWS Lambda is an event-driven, serverless computing platform provided by Amazon as a part of the Amazon Web Services. It is a computing service that runs code in response to events and...

 
 

JPA Tutorial - Ultimate Guide

The Java Persistence API (JPA) is a vendor independent specification for mapping Java objects to the tables of relational databases. Implementations of this specification allow...

 

lunes, 1 de junio de 2020

Breve historia de Haskell


Había una vez un matemático llamado Alonzo Church en la Universidad de Princeton. Church era el supervisor de doctorado de Alan Turing. Church ideó un modelo matemático de funciones llamado cálculo lambda. 

El cálculo lambda captura la esencia de la computación. Implica abstracción de funciones (como definir funciones en Haskell) y aplicaciones (como llamar a funciones en Haskell).

A Uno de los primeros lenguajes de programación de alto nivel fue LISP (que significa procesamiento de lista). LISP adoptó un estilo funcional. Permitía que las funciones del usuario fueran definidas y pasadas como valores. 

Durante la década de 1980, muchos investigadores inventaron y ampliaron varios lenguajes de programación funcionales. Los lenguajes como ML, Hope y Miranda. Sin embargo, la investigación estaba fragmentada en varios lenguajes, y muchos de ellos no eran de "código abierto". Entonces, un grupo de académicos formó un comité para diseñar e implementar un nuevo lenguaje, que se utilizaría como vehículo para la investigación, así como para la enseñanza de la programación funcional.

Después de varios años de trabajo y argumentos, el comité publicó el primer Informe del lenguaje Haskell en 1990. Este fue un hito importante: al fin hubo un lenguaje funcional común en torno al cual la comunidad de investigación podía unirse.

El lenguaje ha crecido en popularidad desde entonces, a pesar del objetivo declarado de evitar el éxito a toda costa. Hay varias implementaciones disponibles gratuitamente. El más utilizado es el Glasgow Haskell Compiler, que tiene un intérprete (ghci) y un compilador (ghc). Estos forman parte integral de la plataforma Haskell. Mucha gente contribuyó a este ecosistema de software. 


Esta historia puede estar mejor contada en este video: 


Erlang en el panorama de la programación funcional.

Erlang es pragmático. Erlang es funcional, pero permite algunos efectos secundarios. Por ejemplo, la forma en que se maneja la comunicación en Erlang es como un efecto secundario. Pero Erlang evita algunos tipos de efectos secundarios. No mantiene estado, tiene lo que se llama asignación única estática. Entonces, aunque el lenguaje en sí es relativamente libre, hay herramientas que ayudan a garantizar la seguridad de los programas que escribimos. Así que hay un buen equilibrio pragmático. 

Si nos fijamos en el panorama del lenguaje de programación funcional, hay bastantes lenguajes que se denominan funcionales. Muchos lenguajes son lo que se llama fuertemente tipado. Lo que queremos decir con tipado fuerte es que cualquier error de tipo que sucede en el lenguaje, lo obtendremos en el momento de la compilación. No se obtienen errores de tipo de tiempo de ejecución. En este grupo tenemos lenguajes como Haskell y Miranda, que tienen lo que se denomina evaluación perezosa.

Lo que eso significa es que la evaluación de las expresiones está impulsada por la demanda. Entonces, en lugar de la evaluación tradicional, que se llama evaluación estricta, donde los argumentos de las funciones se evalúan a medida que se pasan a la función, antes de evaluar el cuerpo de la función. En Haskell y Miranda, los argumentos solo se evalúan cuando la evaluación del cuerpo lo requiere. Por lo tanto, es muy posible que un argumento no se evalúe en absoluto. O es posible que un compuesto, una estructura de datos, solo se evalúe parcialmente. Y esto permite tipos de estructuras de datos infinitos. 

A la vez Haskell y Miranda son completamente puros. No tienen ningún efecto secundario en absoluto. Y eso se debe a que los efectos secundarios y la evaluación perezosa encajan muy mal. La pereza te obliga a ser puro. Esto se debe a que no sabe cuándo se evaluarán partes particulares de una expresión. Entonces, no sabes cuándo ocurriría ese efecto secundario, si estuviera allí. Por otro lado, lenguajes como ML y OCaml y F# tienen una evaluación estricta. Y tienen algunas impurezas. Diferentes lenguajes tienen diferentes equilibrios de impureza, así como Erlang tiene efectos secundarios, tiene impureza en sus primitivas de comunicación. 

Los demás, ML, OCaml, etc., la familia ML son estrictos. Pero estos lenguajes están fuertemente tipados. En el otro extremo del espectro, hay lenguajes débilmente tipados de la familia LISP. Y estos son inherentemente no escritos, si lo desea. Porque construido en el corazón de ellos, tienen una función de evaluación. Entonces puede construir datos y luego evaluar esos datos. Por lo tanto, no hay forma de que sepa de antemano qué tipo de datos tendrá la construcción cuando se evalúen. LISP tiene una larga historia. LISP se inventó por primera vez hace más de 50 años. Y los descendientes de LISP como Common Lisp y Scheme y Racket se usan ampliamente en la actualidad. Pero el núcleo de esos lenguajes es el uso sofisticado de macros y el uso de eval para hacer que estos lenguajes sean muy reflexivos. Pero eso difiere del tipo de cosas que se hacen en Erlang. 

Si para ser un lenguaje de programación funcional, todo lo que necesita es tener una lambda que le permita definir funciones anónimas, entonces tenemos una gran clase de lenguajes de programación funcional. Debido a que Java, JavaScript, Ruby, C ++, casi todos los lenguajes en los que se puede imaginar están obteniendo un lambda, permiten la facilidad de tener funciones anónimas simplemente porque han demostrado ser muy útiles en paradigmas de programación funcional como MapReduce, etc. Pero no se puede considerara estos últimos lenguajes como funcionales.