Programación reactiva + bases de datos relacionales = R2DBC

Continuamos con Programación reactiva y bases de datos relacionales.

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: 

https://github.com/r2dbc

https://r2dbc.io

https://spring.io/projects/spring-data-r2dbc

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: 

https://r2dbc.io/

https://github.com/eclipse-vertx/vertx-sql-client

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"

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. 

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.

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...

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. 

repl.it, Una super IDE online

repl.it es un IDE gratuito, colaborativo y en el navegador para codificar en más de 50 lenguajes, sin gastar un segundo en la configuración.

Les cuento, quería probar algo en Haskell y me encontré con esta joya. Esta muy bueno, te haces un usuario si queres, codeas y si configuraste un repo en github te guarda los archivos ahí. Podes compartir codigo, trabajar en equipo...

Podes programar en : 

Python, Nodejs, C, Java, C++, Ruby, HTML, CSS, JS, Lisp, Go, Rust, Roy, kotlin, Swift, F#, C#, etc...

Punto bajo, no permite ni Scala, ni Grovyy... 

Dejo link: https://repl.it/

Crear un árbol binario con Haskell

En informática, los árboles crecen al revés. La raíz única está en la parte superior, y las hojas están en la parte inferior. En realidad depende como se lo vea. 

El árbol binario se usa a menudo para almacenar datos ordenados, para permitir una búsqueda eficiente, por ejemplo, un directorio telefónico.

Vamos a definir un tipo de datos Haskell para árboles, almacenando valores enteros.

data Tree = Leaf | Node Int Tree Tree deriving Show

Un valor de árbol puede ser una hoja o un nodo. Tenga en cuenta que este es un tipo de datos recursivo, ya que un Nodo almacena un árbol de enteros y tiene ramificaciones a dos subárboles (a veces llamados hijos). Como se ve definimos que un árbol es una hoja o un nodo con el dato y dos arboles. 

Aquí está el árbol más simple: es solo una hoja.

Leaf

Aquí hay un árbol con un Nodo que contiene el valor 3 y dos hojas.

Node 3 Leaf Leaf

Si escribe esto en ghci, verá los valores devueltos cuando construya estos árboles, siempre que su tipo de datos Tree derive la clase Show type.

El tipo de este valor es:

let l = Node 3 Leaf Leaf

:t l

El tipo del nodo constructor:

:t Node

Esta es una función: el nodo constructor toma tres argumentos y devuelve un resultado de árbol.

Ahora escribamos una función para calcular la profundidad de un árbol: esta es la cantidad máxima de ramas desde la raíz hasta cualquier hoja. Para escribir esta función, haremos coincidir patrones en los diferentes tipos de árbol, es decir, valores de hoja y nodo. Cada hoja es un caso base, pero para cada nodo, necesitamos procesar recursivamente los dos árboles secundarios.

treeDepth :: Tree -> Int

treeDepth Leaf = 0

treeDepth (Node _ leftSubtree rightSubtree) = 

  1 + max (treeDepth leftSubtree) (treeDepth rightSubtree)

Observe el _ en la línea 3, que es un valor de "don’t care" o "no me importa", ya que descartamos el entero en cada nodo.

¿Qué tal una función para verificar si un árbol está ordenado correctamente? La estructura de datos invariable que queremos es que, para cualquier valor de almacenamiento de Nodo x, todos los valores en su subárbol izquierdo sean <x, y todos los valores en su subárbol derecho sean> = x.

Entonces, esta función tomará un Árbol, un valor mínimo, un valor máximo y devolverá un Bool. isSortedTree :: Árbol -> Int -> Int -> Bool

Una hoja se ordena automáticamente, ya que no contiene un valor. Para cada nodo, tenemos que verificar que el valor entre los valores mínimo y máximo, que comienzan lo más lejos posible, luego se dividen en rangos más pequeños según el valor en el nodo.

isSortedTree :: Tree -> Int -> Int -> Bool

isSortedTree Leaf _ _ = True

isSortedTree (Node x leftSubtree rightSubtree) minVal maxVal =

    let leftSorted   = isSortedTree leftSubtree minVal x

        rightSorted = isSortedTree rightSubtree x maxVal

    in x >= minVal && x< maxVal && leftSorted && rightSorted

Hasta ahora, hemos estudiado las funciones de recorrido del árbol, donde revisamos la estructura de datos del árbol y hacemos algunos cálculos incrementales en cada nodo. Ahora queremos hacer una función de modificación del árbol. Esto genera un nuevo árbol que es una versión modificada del árbol de entrada.

La función particular que vamos a definir inserta un nuevo valor máximo. Pasamos por el árbol de entrada hasta encontrar el nodo de la derecha con una hoja a la derecha, luego reemplazamos esta hoja de la derecha con un nuevo nodo que contiene un nuevo valor máximo (uno más grande que el valor máximo anterior).

addNewMax :: Tree -> Tree

-- add a new max element to tree

addNewMax Leaf = Node 0 Leaf Leaf  -- input tree with no nodes

addNewMax (Node x t1 Leaf) = Node x t1 (Node (x+1) Leaf Leaf)  -- this is the rightmost Node

addNewMax (Node x t1 t2) = Node x t1 (addNewMax t2) -- intermediate node, go down right subtree

Esta función addNewMax toma un valor de entrada de árbol y devuelve un valor de salida de árbol. 

Inscripción gratuita a MongoDB.live

Me llego el siguiente mail de la gente de MongoDB para anotarme a Mongo.live un evento gratuito donde podes aprender sobre esta gran base de datos NoSql :

Únanse el 9 y 10 de junio* a MongoDB.live para profundizar en el contenido educativo y conocer las nuevas tecnologías. Aprenderá de los expertos en MongoDB para resolver desafíos y adelantarse a la competencia. En MongoDB.live podrás: Personalizar tu experiencia con sesiones centradas en temas como arquitectura de aplicaciones, rendimiento de consultas, modelo de datos, diseño de esquemas, análisis, seguridad, microservicios, migración a la nube y más. Aprender de los clientes de MongoDB en todos los sectores sobre las herramientas y características que están utilizando para aumentar la agilidad de su organización y la productividad de sus equipos de desarrollo. ¡Participar durante la conferencia para ganar puntos de actividad y competir con otros asistentes para ganar premios! Regístrese gratis ahora Después de asistir, estará equipado con los conocimientos esenciales para crear y administrar aplicaciones basadas en datos. ¡Esperamos verte ahí! * MongoDB.live comenzará a las 10:00 a.m. ET el 9 de junio y se extenderá hasta el 10 de junio a las 4:00 p.m. ET.

MongoDB Inc., 2020. All rights reserved. 1633 Broadway, Floor 38, New York, NY 10019 Unsubscribe or change your email preferences. View in browser

Libros Gratuitos de Java Code Geek

Download IT Guides!   Vaadin Programming Cookbook Vaadin is an open source web framework for rich Internet applications. In contrast to JavaScript libraries and browser-plugin based solutions, it features a server-side architecture,...     GWT Programming Cookbook Google Web Toolkit, or GWT Web Toolkit, is an open source set of tools that allows web developers to create and maintain complex JavaScript front-end applications in Java. Other than a...     Amazon Elastic Beanstalk Tutorial AWS Elastic Beanstalk is an orchestration service offered from Amazon Web Services for deploying infrastructure which orchestrates various AWS services, including EC2, S3, Simple...     Hibernate Tutorial Hibernate ORM (Hibernate in short) is an object-relational mapping framework, facilitating the conversion of an object-oriented domain model to a traditional relational database....

Revolution.OS.2001

Quiero recomendarles un buen documental para pasar la pandemia : 

y de yapa:

Design patterns

Quiero recomendar una pagina de patrones de diseño que esta buenisima, trae una descripción de casi todos los patrones con ejemplos y código. El codigo esta en deferentes lenguajes. 

Dejo link : https://refactoring.guru/design-patterns

Juego de Serie en C# con .net core

Cuando quiero aprender un nuevo lenguaje desarrollo un juego de series, es decir aparece una serie con un valor faltante y el jugador debe completarlo.

Uno de los requerimientos no funcionales es que se pueda agregar una serie nueva fácilmente, para cumplirlo vamos a utilizar las ventajas de herencia y polimorfismo.

Vamos a desarrollar este juego en C# para ello creamos el proyecto con : 

$ dotnet new console -lang C#

Luego de esto abrimos nuestro editor favorito, podemos utilizar visual code.  

Empecemos desarrollo de la serie, la serie tiene como responsabilidad generarse y si lo hacemos de esta manera podemos utilizar la potencia del polimorfismo, para que no quede acoplado la generación de la serie con el desarrollo del juego:

using System;

namespace dotNetSecuencia.model

{

    public abstract class Secuencia

    {

        protected int[] nros = new int[4];

        public Secuencia() {

            this.generar();

        }

        public int[] Nro {

            get {

                return nros;

            }

        }

        

        public abstract void generar();

    }

}

Ahora vamos a ver las implementaciones de secuencia:

using System;

namespace dotNetSecuencia.model

{

    public class SecuenciaPar : Secuencia

    {        

        public override void generar() {

            int semilla = new Random ().Next (99) * 2;

            for (int i = 0; i<4; i++) {

                this.nros[i] = (semilla + i * 2); 

            }

        }

    }

}

Y ahora la secuencia Impar: 

using System;

namespace dotNetSecuencia.model

{

    public class SecuenciaImpar : Secuencia

    {

        public override void generar() {

            int semilla = new Random ().Next (99) * 2;

            for (int i = 0; i<4; i++) {

                this.nros[i] = (semilla + i * 2) + 1; 

            }

        }

    }

}

Y ahora la secuencia Fibonacci :

using System;

namespace dotNetSecuencia.model

{

    public class SecuenciaFibonacci : Secuencia

    {

        public override void generar() {

            int until = new Random ().Next (15);

            this.nros[0] = 0;

            this.nros[1] = 1;

            this.nros[2] = 1;

            this.nros[3] = 2;

            for (int i = 0; i<until; i++) {

                 this.nros[0] = this.nros[1];

                 this.nros[1] = this.nros[2];

                 this.nros[2] = this.nros[3];

                 this.nros[3] = this.nros[1] + this.nros[2];

            }

        }

    }

}

Ahora vamos a ver el juego, este tiene la responsabilidad de verificar si el usuario acertó y tambien debe llevar los puntos: 

 using System;

namespace dotNetSecuencia.model

{

    public class Juego

    {

        private int puntaje = 0;

        private Secuencia secuencia = null;

        public Juego() 

        {

            this.generarSecuencia();

        }

        public int Nro1 {

            get {

                return this.secuencia.Nro[0];

            }

        }

        public int Nro2 {

            get {

                return this.secuencia.Nro[1];

            }

        }

        public int Nro4 {

            get {

                return this.secuencia.Nro[3];

            }

        }

        public int Puntaje {

            get {

                return this.puntaje;

            }

        }

        public void generarSecuencia() 

        {

            int semilla = new Random ().Next (3);

            switch (semilla)

            {

                case 0 :

                    this.secuencia = new SecuenciaPar(); 

                break;

                case 1 :

                    this.secuencia = new SecuenciaImpar(); 

                break;

                default:

                    this.secuencia = new SecuenciaFibonacci();

                break;

            }

        }

        public bool isOk(int valor) {

            bool result = false;

            if (this.secuencia.Nro[2] == valor) {

                this.puntaje++;

                result = true;

            } else {

                this.puntaje--;

            }

            this.generarSecuencia();

            return result;

        }

    }

}

Ahora programemos la interfaz por consola por supuesto : 

using System;

using dotNetSecuencia.model;

namespace dotNetSecuencia

{

    class Program

    {

        static void Main(string[] args)

        {

            Console.WriteLine("Bienvenido !!");

            Juego juego = new Juego();

            String respuestaStr;

            do {

                Console.WriteLine("La secuencia es : ");

                Console.WriteLine(" " + juego.Nro1 + " " + juego.Nro2 + "  __  " + juego.Nro4 );

                respuestaStr = Console.ReadLine();

                int respuesta = Convert.ToInt32(respuestaStr);

                if (juego.isOk(respuesta)) {

                    Console.WriteLine("Ganaste!! Tu puntaje es " + juego.Puntaje);

                } else {

                    Console.WriteLine("Perdiste!! Tu puntaje es " + juego.Puntaje);

                }

                Console.WriteLine("Quieres seguir Jugando [n/s] ? ");

                respuestaStr = Console.ReadLine();

            } while (respuestaStr != "n");

        }

    }

}

Y eso es todo!!! a jugar se a dicho!!

Dejo el repositorio git: 

https://github.com/emanuelpeg/secuenciaCSharp