¿Qué es Rust?

Rust es un nuevo lenguaje de programación que tuvo su versión 1.0 en 2015:

• Rust es un lenguaje compilado estáticamente con un papel similar al de C++
• rustc usa LLVM como backend.
• Rust admite muchas plataformas y arquitecturas:
• x86, ARM, WebAssembly, …
• Linux, Mac, Windows,…
• Rust se utiliza para una amplia gama de dispositivos:
• firmware y cargadores de arranque,
• pantallas inteligentes,
• teléfonos móviles,
• escritorios,
• servidores.

Rust encaja en la misma área que C++:

• Alta flexibilidad.
• Alto nivel de control.
• Se puede programar para dispositivos muy limitados, como teléfonos móviles.
• No tiene runtime, ni recolección de basura.
• Se centra en la fiabilidad y la seguridad sin sacrificar el rendimiento.

Pasemos al programa Rust más simple posible, un programa clásico de Hello World:

fn main() {

    println!("Hello 🌍!");

}

$ cargo run

   Compiling hello_cargo v0.1.0 (/home/emanuel/Projects/rust/hello_cargo)

    Finished dev [unoptimized + debuginfo] target(s) in 0.26s

     Running `target/debug/hello_cargo`

Hello 🌍!

Lo que ves:

• Las funciones se introducen con fn.
• Los bloques están delimitados por llaves como en C y C++.
• La función principal es el punto de entrada del programa.
• Rust tiene macros higiénicas, println! es un ejemplo de esto.
• Las cadenas Rust están codificadas en UTF-8 y pueden contener cualquier carácter Unicode.

Puntos clave:

• Rust es muy parecido a otros lenguajes en la tradición C/C++/Java. Es imperativo (no funcional) y no intenta reinventar las cosas a menos que sea absolutamente necesario.
• Rust es moderno con soporte completo para cosas como Unicode.
• Rust usa macros para situaciones en las que desea tener una cantidad variable de argumentos (sin sobrecarga de funciones).
• Las macros que son "higiénicas" significa que no capturan accidentalmente identificadores del ámbito en el que se utilizan. Las macros de Rust son en realidad solo parcialmente higiénicas.

Compilar y ejecutar código Rust con Cargo

Si tenemos instalados bien rust y cargo esto debería funcionar: 

$ rustc --version

rustc 1.65.0

$ cargo --version

cargo 1.65.0

Veamos como crear un binario de Rust a partir de un ejemplo:

$ cargo new exercise

     Created binary (application) `exercise` package

$ cd exercise

$ cargo run

   Compiling exercise v0.1.0 (/home/mgeisler/tmp/exercise)

    Finished dev [unoptimized + debuginfo] target(s) in 0.75s

     Running `target/debug/exercise`

Hello, world!

Reemplace el código de src/main.rs con su propio código. Por ejemplo:

fn main() {

    println!("Hola Rust!");

}

Utilizamos cargo run : 

$ cargo run

   Compiling hello_cargo v0.1.0 (/home/emanuel/Projects/rust/hello_cargo)

    Finished dev [unoptimized + debuginfo] target(s) in 1.06s

     Running `target/debug/hello_cargo`

Hola Rust!

Usamos cargo check para revisar rápidamente el proyecto en busca de errores, usa cargo build para compilarlo sin ejecutarlo. Se encontrará el resultado en target/debug/. Usamos cargo build --release para producir una compilación de versión optimizada en target/release/.

Se puede agregar dependencias para su proyecto editando Cargo.toml. Cuando ejecutamos los comandos de cargo, automáticamente descargará y compilará las dependencias faltantes para usted.

$ cargo build --release

   Compiling hello_cargo v0.1.0 (/home/emanuel/Projects/rust/hello_cargo)

    Finished release [optimized] target(s) in 0.26s

$ cd target/release/

$ ./exercise

Hola Rust!

Y listo!!

Primeros pasos con ZIO parte 4

ZIO puede convertir cualquier código (como una llamada a algún método) en un efecto, ya sea que ese código se llame síncrono (que devuelve directamente un valor) o asíncrono (que pasa un valor a las devoluciones de llamada).

Si se hace correctamente, cuando convierte el código en un efecto ZIO, este código se almacenará dentro del efecto para que ZIO pueda administrarlo y beneficiarse de funciones como reintentos, tiempos de espera y registro automático de errores.

Las funciones de conversión que tiene ZIO le permiten utilizar sin problemas todas las funciones de ZIO con código que no es de ZIO escrito en Scala o Java, incluidas las bibliotecas de terceros.

El código síncrono se puede convertir en un efecto ZIO usando ZIO.attempt:

import scala.io.StdIn

val readLine: ZIO[Any, Throwable, String] = ZIO.attempt(StdIn.readLine())

El tipo de error del efecto resultante siempre será Throwable, porque el código síncrono puede generar excepciones con cualquier valor de tipo Throwable.

Si sabe con certeza que algún código no arroja excepciones (excepto quizás excepciones en tiempo de ejecución), puede convertir el código en un efecto ZIO usando ZIO.succeed:

def printLine(line: String): UIO[Unit] =  ZIO.succeed(println(line))

A veces, es posible que sepa que el código arroja un tipo de excepción específico, y es posible que desee reflejar esto en el parámetro de error de su efecto ZIO.

Para ello, puede utilizar el método ZIO#refineToOrDie:

import java.io.IOException

val readLine2: ZIO[Any, IOException, String] =

  ZIO.attempt(StdIn.readLine()).refineToOrDie[IOException]

El código asíncrono que expone una API basada en devolución de llamada se puede convertir en un efecto ZIO usando ZIO.async:

object legacy {

  def login(

    onSuccess: User => Unit,

    onFailure: AuthError => Unit): Unit = ???

}

val login: ZIO[Any, AuthError, User] =

  ZIO.async[Any, AuthError, User] { callback =>

    legacy.login(

      user => callback(ZIO.succeed(user)),

      err  => callback(ZIO.fail(err))

    )

  }

Los efectos asincrónicos son mucho más fáciles de usar que las API basadas en devolución de llamadas y se benefician de las características de ZIO como la interrupción, la seguridad de los recursos y la gestión de errores.

Algunos códigos sincrónicos pueden participar en el llamado bloqueo de E/S, que pone un subproceso en un estado de espera, mientras espera que se complete alguna llamada del sistema operativo. Para obtener el máximo rendimiento, este código no debe ejecutarse en el grupo de subprocesos principal de su aplicación, sino en un grupo de subprocesos especial dedicado a operaciones de bloqueo.

ZIO tiene un grupo de subprocesos de bloqueo integrado en el tiempo de ejecución y le permite ejecutar efectos allí con ZIO.blocking:

import scala.io.{ Codec, Source }

def download(url: String) =

  ZIO.attempt {

    Source.fromURL(url)(Codec.UTF8).mkString

  }

def safeDownload(url: String) =

  ZIO.blocking(download(url))

Como alternativa, si desea convertir el código de bloqueo directamente en un efecto ZIO, puede usar el método ZIO.attemptBlocking:

val sleeping =

  ZIO.attemptBlocking(Thread.sleep(Long.MaxValue))

El efecto resultante se ejecutará en el grupo de subprocesos de bloqueo de ZIO.

Si tiene algún código síncrono que responderá a Thread.interrupt de Java (como Thread.sleep o código basado en bloqueo), entonces puede convertir este código en un efecto ZIO interrumpible usando el método ZIO.attemptBlockingInterrupt.

Algunos códigos síncronos solo se pueden cancelar invocando algún otro código, que es responsable de cancelar el cálculo en ejecución. Para convertir dicho código en un efecto ZIO, puede usar el método ZIO.attemptBlockingCanceble:

import java.net.ServerSocket

import zio.UIO

def accept(l: ServerSocket) =

  ZIO.attemptBlockingCancelable(l.accept())(ZIO.succeed(l.close()))

Pekko: El fork open source de Akka que impulsa la escalabilidad en sistemas concurrentes

En el mundo de la programación concurrente y distribuida, Akka ha sido una herramienta ampliamente reconocida y utilizada. Sin embargo, recientemente hubo un cambio de licencia que no cayo nada bien pero por suerte aparecio Pekko, un fork open source de Akka que busca llevar la escalabilidad de sistemas concurrentes a un nuevo nivel. 

¿Qué es Pekko? Pekko es un fork open source de Akka, un framework de programación concurrente y distribuida basado en el modelo de actores. Al igual que Akka, Pekko proporciona una forma elegante y eficiente de construir sistemas altamente concurrentes y escalables. 

Arquitectura de bajo acoplamiento: Pekko ha sido diseñado con una arquitectura de bajo acoplamiento que permite un mejor aislamiento y desacoplamiento entre los actores. Esto se traduce en una mayor flexibilidad y capacidad de escalar los sistemas de forma eficiente.

Rendimiento mejorado: Pekko ha optimizado el rendimiento en comparación con Akka, especialmente en escenarios de alto tráfico y carga intensiva. Gracias a su implementación eficiente y algoritmos optimizados, Pekko es capaz de manejar un mayor número de mensajes por segundo y reducir la latencia en las comunicaciones.

Escalabilidad elástica: Pekko ha introducido un enfoque innovador para la escalabilidad elástica, permitiendo que los sistemas se adapten automáticamente a las demandas cambiantes de carga. Esto se logra mediante la capacidad de ajustar dinámicamente la cantidad de recursos asignados a los actores en función de la demanda, lo que garantiza un rendimiento óptimo en todo momento.

Mejoras en la tolerancia a fallos: Pekko ha fortalecido los mecanismos de tolerancia a fallos, lo que garantiza una mayor robustez en entornos distribuidos. Mediante la implementación de estrategias de recuperación y supervisión mejoradas, Pekko ayuda a gestionar los errores y a mantener la estabilidad del sistema, incluso en situaciones adversas.

Facilidad de migración: Pekko ha sido diseñado para facilitar la migración desde Akka. Los desarrolladores pueden aprovechar su experiencia previa con Akka y adaptarse rápidamente a Pekko sin mayores obstáculos.

Comunidad activa: Pekko cuenta con una comunidad open source vibrante y activa. Esto implica que los desarrolladores pueden colaborar, compartir conocimientos y contribuir a la mejora continua del proyecto.

Documentación exhaustiva: Pekko ofrece una documentación completa y bien estructurada, que incluye guías, tutoriales y ejemplos de código. Esto facilita la adopción y el aprendizaje de la herramienta.

Por ahora Pekko esta en incubador de apache pero creo que tiene futuro. 

Pekko representa un emocionante avance en el mundo de la programación concurrente y distribuida. Con su enfoque en la escalabilidad, rendimiento y facilidad de uso, este fork open source de Akka ofrece una alternativa sólida y poderosa para desarrolladores y arquitectos de sistemas. Si estás interesado en construir sistemas concurrentes altamente escalables, Pekko definitivamente merece tu atención.

Dejo link : https://pekko.apache.org/

Mi experiencia con la programación funcional en Scala

Creo que si leen este blog saben que me encanta la programación funcional y investigar y aprender. Y en eso estoy...

Me gustaría contar un poco mi evolución y mis altibajos para que la gente que sabe me aconseje y los que no saben puedan aprender de mis exitos y derrotas. 

Bueno, todo empezó con un curso de scala de coursera y quede encantado con el lenguaje y la programación funcional. De a poco tambien me interiorice en otros lenguajes como erlang, haskell, Clojure, Elixir, F#, etc ... pero siempre en la volvía a Scala por gusto nomas. Y me iba bastante bien...

Hasta que empece a quedarme corto en scala, quería progresar y decidí ver algunos framework funcionales, leí un libro de Cats y la verdad es que si bien esta bueno, me frustre mucho... porque no sabia porque se hacían ciertas cosas, no entendía porque tan complejo o si bien entendía desconfiaba ( no hay otra forma de hacerlo más fácil) y bueno ... 

Cambie a Akka, y me pareció bueno y me sentí más en mi mundo, pero justo justo cuando volvia el entuciasmo, cambio de licencia y bueno... Se fue el entusiasmo, ahora sé que existe un fork open source llamado pekko (https://github.com/apache/incubator-pekko) y es de apache. Pero lo veo verde, y no sé cuanto va a crecer ...

Y ahora estoy con ZIO y por ahora todo va bien, por ende la conclusión es si quieren progresar en su conocimiento en Scala, y no vienen del mundo funcional como Haskell, ZIO esta bueno. 

Si son nuevos en el mundo funcional y scala, yo haría lo siguiente: 

1. Estudiar Scala (curso de scala de coursera, el libro rojo de programación funcional en scala, etc ...)

2. Leer y estudiar ZIO 

3. Leer y estudiar Cats

Pero no perder de vista Pekko, para ver como progresa. 

Que opinan? 

El ecosistema de Rust

El ecosistema de Rust consta de una serie de herramientas, de las cuales las principales son:

• rustc: el compilador de Rust que convierte los archivos .rs en binarios y otros formatos intermedios.
• cargo: el administrador de dependencias de Rust y la herramienta de compilación. Cargo sabe cómo descargar dependencias alojadas en https://crates.io y las pasará a rustc cuando construyas el proyecto. Cargo también viene con un runtime de prueba incorporado que se utiliza para ejecutar pruebas unitarias.
• rustup: el instalador y actualizador de la cadena de herramientas de Rust. Esta herramienta se usa para instalar y actualizar rustc y cargo cuando se lanzan nuevas versiones de Rust. Además, rustup también puede descargar documentación para la biblioteca estándar. Puede tener varias versiones de Rust instaladas a la vez y rustup le permitirá cambiar entre ellas según sea necesario.

Primeros pasos con ZIO parte 3

Vamos a crear efectos funcionales de ZIO, y podemos hacerlo a partir de valores, cálculos y tipos de datos comunes de Scala.

Usando el método ZIO.succeed, se puede crear un efecto que, cuando se ejecute, tendrá éxito con el valor especificado:

val s1 = ZIO.succeed(42)

El método de succeed toma un parámetro, que garantiza que si le pasa al método algún código para ejecutar, este código se almacenará dentro del efecto ZIO para que ZIO pueda administrarlo y beneficiarse de características como reintentos, tiempos de espera y registro automático de errores.

Usando el método ZIO.fail, puede crear un efecto que, cuando se ejecuta, fallará con el valor especificado:

val f1 = ZIO.fail("Uh oh!")

Para el tipo de datos ZIO, no hay restricción en el tipo de error. Se puede usar cadenas, excepciones o tipos de datos personalizados.

Podemos usar excepciones :

val f2 = ZIO.fail(new Exception("Uh oh!"))

La biblioteca estándar de Scala contiene varios tipos de datos que se pueden convertir en efectos ZIO.

Un Option se puede convertir en un efecto ZIO usando ZIO.fromOption:

val zoption: IO[Option[Nothing], Int] = ZIO.fromOption(Some(2))

Option[Nothing], lo que significa que si dicho efecto falla, fallará con el valor Nothing (que tiene el tipo Opción[Nothing]).

Puede transformar una falla en algún otro valor de error usando orElseFail, uno de los muchos métodos que proporciona ZIO para la gestión de errores:

val zoption2: ZIO[Any, String, Int] = zoption.orElseFail("It wasn't there!")

ZIO tiene una variedad de otros operadores diseñados para facilitar el manejo de Option. En el siguiente ejemplo, los operadores Some y asSomeError se utilizan para facilitar la interfaz con los métodos que devuelven Option, similar al tipo OptionT en algunas bibliotecas de Scala.

val maybeId: ZIO[Any, Option[Nothing], String] = ZIO.fromOption(Some("abc123"))

def getUser(userId: String): ZIO[Any, Throwable, Option[User]] = ???

def getTeam(teamId: String): ZIO[Any, Throwable, Team] = ???

val result: ZIO[Any, Throwable, Option[(User, Team)]] = (for {

  id   <- maybeId

  user <- getUser(id).some

  team <- getTeam(user.teamId).asSomeError 

} yield (user, team)).unsome 

Un Some se puede convertirse en un efecto ZIO usando ZIO.fromEither:

val zeither: ZIO[Any, Nothing, String] = ZIO.fromEither(Right("Success!"))

El tipo de error del efecto resultante será el del caso Izquierdo (Left), mientras que el tipo de éxito será el del caso Derecho (Right).

Un valor Try se puede convertir en un efecto ZIO usando ZIO.fromTry:

import scala.util.Try

val ztry = ZIO.fromTry(Try(42 / 0))

El tipo de error del efecto resultante siempre será Throwable porque Try solo puede fallar con valores de tipo Throwable.

Un Scala Future se puede convertir en un efecto ZIO usando ZIO.fromFuture:

import scala.concurrent.Future

lazy val future = Future.successful("Hello!")

val zfuture: ZIO[Any, Throwable, String] =  ZIO.fromFuture { implicit ec =>

    future.map(_ => "Goodbye!")

  }

La función pasada a fromFuture recibe un ExecutionContext, que permite a ZIO administrar dónde se ejecuta Future (por supuesto, puede ignorar este ExecutionContext).

El tipo de error del efecto resultante siempre será Throwable, porque los valores Future solo pueden fallar con valores de tipo Throwable.

Vamos a instalar Cargo para programar en Rust

No se si da para un post porque tengo linux, y es solo ejecutar : 

$ sudo apt install cargo rust-src rustfmt

y listo!! 

Si todo salio bien, van a hacer : 

$ cargo --version

cargo 1.65.0

Y se imprime la versión de cargo. 

Vamos a hacer un hola mundo, creemos un proyecto: 

cargo new hello_cargo

cd hello_cargo

En Cargo.toml podemos ver datos del proyecto y las dependencias : 

$ ls

Cargo.toml  src

$ cat Cargo.toml 

[package]

name = "hello_cargo"

version = "0.1.0"

edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

Y podemos ver el código rust en src/main.rs

$ cat src/main.rs

fn main() {

    println!("Hello, world!");

}

Y con cargo build compilamos y cargo run corremos : 

$ cargo build

   Compiling hello_cargo v0.1.0 (...rust/hello_cargo)

    Finished dev [unoptimized + debuginfo] target(s) in 0.87s

$ cargo run 

    Finished dev [unoptimized + debuginfo] target(s) in 0.04s

     Running `target/debug/hello_cargo`

Hello, world!

Y listo!! 

Dejo link: https://doc.rust-lang.org/book/ch01-03-hello-cargo.html

La potencia de la programación funcional en Java con Vavr

 

En el mundo del desarrollo de software, los lenguajes funcionales están ganando popularidad debido a su enfoque en la inmutabilidad, la programación declarativa y las operaciones funcionales. Java, siendo un lenguaje orientado a objetos por naturaleza, carece de muchas características propias de los lenguajes funcionales. Sin embargo, gracias al framework Vavr, los desarrolladores de Java pueden aprovechar al máximo los conceptos y las ventajas de la programación funcional. 

Vavr es un framework funcional para Java 8 y superior que proporciona una biblioteca de clases y funciones para facilitar la programación funcional en Java. Ofrece una amplia gama de características, incluyendo tipos inmutables, operaciones funcionales, manejo de errores y mucho más. Vavr se basa en el paradigma funcional y promueve el uso de funciones puras, evitando los efectos secundarios y facilitando la escritura de código más limpio y conciso.

Características principales de Vavr:

• Tipos inmutables: Vavr proporciona una serie de tipos inmutables, como List, Set, Option, Try, etc. Estos tipos aseguran que los objetos no puedan ser modificados una vez creados, lo que ayuda a prevenir errores y garantiza la consistencia del estado.
• Operaciones funcionales: Vavr ofrece una amplia gama de operaciones funcionales, como map, filter, reduce, flatMap, etc. Estas operaciones permiten manipular y transformar colecciones de datos de manera elegante y expresiva.
• Patrones de concurrencia: Vavr ofrece una API concisa y segura para trabajar con concurrencia en Java. Proporciona constructores de hilos, promesas y otras estructuras de datos para facilitar la programación concurrente.
• Manejo de errores: Vavr ofrece una forma más robusta y funcional de manejar errores en Java. El tipo Try captura excepciones y permite manejarlas de manera más elegante y comprensible.
• Validaciones: Vavr proporciona una API para realizar validaciones de manera concisa y declarativa. Permite combinar múltiples validaciones y proporciona mensajes de error claros y comprensibles.

Entre las ventajas de usar Vavr tenemos :

• Código más legible y conciso: Las características funcionales de Vavr permiten escribir código más legible y conciso. El uso de funciones puras y tipos inmutables reduce la complejidad y mejora la mantenibilidad del código.
• Programación segura: Al evitar los efectos secundarios y promover la inmutabilidad, Vavr ayuda a prevenir errores y garantizar la integridad del código.
• Compatibilidad con Java existente: Vavr se integra perfectamente con el código Java existente, lo que permite aprovechar las ventajas de la programación funcional sin necesidad de cambiar todo el código base.
• Curvas de aprendizaje suaves: Si estás familiarizado con conceptos de programación funcional, la curva de aprendizaje de Vavr es bastante suave. Vavr proporciona una API coherente y bien documentada que facilita su adopción.

Vavr es un framework funcional poderoso que proporciona a los desarrolladores de Java las herramientas necesarias para aprovechar al máximo los conceptos de programación funcional. Con su amplia gama de características y su fácil integración con el código Java existente, Vavr puede ayudar a mejorar la calidad del código, la legibilidad y la mantenibilidad de las aplicaciones Java. 

Veamos un ejemplo de lo que podemos hacer con Vavr: 

import io.vavr.collection.List;

import io.vavr.control.Option;

public class VavrExample {

    public static void main(String[] args) {

        // Tipos inmutables

        List<Integer> numbers = List.of(1, 2, 3, 4, 5);

        List<Integer> squaredNumbers = numbers.map(n -> n * n);

        System.out.println(squaredNumbers); // Imprime: List(1, 4, 9, 16, 25)

        // Operaciones funcionales

        int sum = squaredNumbers.reduce((a, b) -> a + b);

        System.out.println("Suma: " + sum); // Imprime: Suma: 55

        // Option: manejo de valores nulos

        Option<String> name = Option.of("John");

        String upperCaseName = name.map(String::toUpperCase)

                                   .getOrElse("N/A");

        System.out.println(upperCaseName); // Imprime: JOHN

        Option<String> nullName = Option.of(null);

        String nullSafeName = nullName.map(String::toUpperCase)

                                      .getOrElse("N/A");

        System.out.println(nullSafeName); // Imprime: N/A

    }

}

Dejo link: https://www.vavr.io/

Primeros pasos con ZIO parte 2

ZIO es framework para crear aplicaciones nativas en la nube. Con un núcleo funcional amigable para principiantes pero poderoso, ZIO permite a los desarrolladores crear rápidamente aplicaciones con las mejores prácticas que son altamente escalables, comprobables, robustas, resistentes, seguras para los recursos, eficientes y observables.

En el corazón de ZIO se encuentra un poderoso tipo de datos llamado ZIO, que es el bloque de construcción fundamental para cada aplicación ZIO.

El tipo de datos ZIO se denomina efecto funcional y representa una unidad de cálculo dentro de una aplicación ZIO. Al igual que un modelo o un flujo de trabajo, los efectos funcionales son planes precisos que describen un cálculo o una interacción. Cuando se ejecuta una aplicación ZIO, un efecto funcional fallará con algún tipo de error o tendrá éxito con algún tipo de valor.

Al igual que el tipo de datos List, el tipo de datos ZIO es un tipo de datos genérico y usa parámetros de tipo para mejorar la seguridad de tipos. El tipo de datos de Lista tiene un solo parámetro de tipo, que representa el tipo de elemento que se almacena en la Lista. El tipo de datos ZIO tiene tres parámetros de tipo: ZIO[R, E, A].

Los parámetros de tipo del tipo de datos ZIO tienen los siguientes significados:

• R - Tipo de entorno. El parámetro de tipo de entorno representa el tipo de datos contextuales que requiere el efecto antes de que se pueda ejecutar. Por ejemplo, algunos efectos pueden requerir una conexión a una base de datos, mientras que otros pueden requerir una solicitud HTTP y otros pueden requerir una sesión de usuario. Si el parámetro de tipo de entorno es Any, entonces el efecto no tiene requisitos, lo que significa que el efecto se puede ejecutar sin proporcionarle primero un contexto específico.
• E - Tipo de falla. El parámetro tipo de falla representa el tipo de error con el que el efecto puede fallar cuando se ejecuta. Aunque Exception o Throwable son tipos de falla comunes en las aplicaciones ZIO, ZIO no impone ningún requisito sobre el tipo de error y, a veces, es útil definir tipos de error comerciales o de dominio personalizados para diferentes partes de una aplicación. Si el parámetro de tipo de error es Nothing, significa que el efecto no puede fallar.
• A - Tipo de éxito. El parámetro de tipo de éxito representa el tipo de éxito con el que el efecto puede tener éxito cuando se ejecuta. Si el parámetro de tipo de éxito es Unit, significa que el efecto no produce información útil (similar a un método de devolución de vacío), mientras que si es Nothing, significa que el efecto se ejecuta para siempre, a menos que falle.

Como varios ejemplos de cómo interpretar los tipos de efectos ZIO:

• Un efecto de tipo ZIO[Any, IOException, Byte] no tiene requisitos y, cuando se ejecuta, dicho efecto puede fallar con un valor de tipo IOException o puede tener éxito con un valor de tipo Byte.
• Un efecto de tipo ZIO[Connection, SQLException, ResultSet] requiere una conexión y, cuando se ejecuta, dicho efecto puede fallar con un valor de tipo SQLException o puede tener éxito con un valor de tipo ResultSet.
• Un efecto de tipo ZIO[HttpRequest, HttpFailure, HttpSuccess] requiere una HttpRequest y, cuando se ejecuta, dicho efecto puede fallar con un valor de tipo HttpFailure o puede tener éxito con un valor de tipo HttpSuccess.

El parámetro de tipo de entorno es un parámetro de tipo compuesto porque, a veces, un solo efecto puede requerir varios valores de diferentes tipos. Si ve que un efecto tiene un tipo de ZIO[UserSession with HttpRequest, E, A] (Scala 2.x) o ZIO[UserSession & HttpRequest, E, A] (Scala 3.x), significa que el efecto requiere múltiples valores contextuales antes de que pueda ejecutarse.

Aunque esta analogía no es precisa, se puede pensar en un efecto ZIO como una función:

R => Either[E, A]

Esta función requiere una R y produce una falla de tipo E o un valor de éxito de tipo A.

Los efectos ZIO no son en realidad funciones, por supuesto, porque modelan cálculos e interacciones complejos, que pueden ser asincrónicos, concurrentes o ingeniosos.

El tipo de datos ZIO es el único tipo de efecto en ZIO. Sin embargo, hay una familia de alias de tipo que reducen la necesidad de escribir:

• UIO[A]: un alias de tipo para ZIO[Any, Nothing, A], que representa un efecto que no tiene requisitos, no puede fallar y puede tener éxito con una A.
• URIO[R, A]: un alias de tipo para ZIO[R, Nothing, A], que representa un efecto que requiere una R, no puede fallar y puede tener éxito con una A.
• Task[A]: un alias de tipo para ZIO[Any, Throwable, A], que representa un efecto que no tiene requisitos, puede fallar con un valor Throwable o tener éxito con una A.
• RIO[R, A]: un alias de tipo para ZIO[R, Throwable, A], que representa un efecto que requiere una R, puede fallar con un valor Throwable o tener éxito con una A.
• IO[E, A]: un alias de tipo para ZIO[Any, E, A], que representa un efecto que no tiene requisitos, puede fallar con una E o tener éxito con una A.

Si es nuevo en los efectos funcionales, le recomendamos que comience con el tipo de tarea, que tiene un solo parámetro de tipo y se corresponde más con los tipos de datos futuros integrados en las bibliotecas estándar de Scala y Java.

Si está utilizando bibliotecas Cats Effect, puede encontrar útil el tipo RIO, ya que le permite enhebrar el contexto a través de bibliotecas de terceros.

Independientemente del tipo de alias que utilice en su aplicación, UIO puede ser útil para describir efectos infalibles, incluidos los que resultan del manejo de todos los errores.

Finalmente, si es un programador funcional experimentado, se recomienda el uso directo del tipo de datos ZIO, aunque puede resultarle útil crear su propia familia de alias de tipo en diferentes partes de su aplicación.

Si se siente cómodo con el tipo de datos ZIO y su familia de alias de tipo, el siguiente paso es aprender a crear efectos ...

Primeros pasos con ZIO

Empecemos desde el principio, incluyamos ZIO en nuestro proyecto agregando la siguiente dependencia en el build.sbt:

libraryDependencies += "dev.zio" %% "zio" % "2.0.13"

Para hacer una aplicación ZIO podemos hacer que nuestra aplicación extienda de ZIOAppDefault, que permite escribir todo el programa usando ZIO:

import zio._

import zio.Console._

object MyApp extends ZIOAppDefault {

  def run = myAppLogic

  val myAppLogic =

    for {

      _    <- printLine("Hello! What is your name?")

      name <- readLine

      _    <- printLine(s"Hello, ${name}, welcome to ZIO!")

    } yield ()

}

El método run debemos devolver un valor ZIO que tiene todos sus errores manejados, que, en la jerga de ZIO, es un valor ZIO no excepcional.

Una forma de hacer esto es invocar un pliegue sobre un valor ZIO, para obtener otro valor ZIO no excepcional. Eso requiere dos funciones de controlador: de E => B (el controlador de errores) y de A => B (el controlador de éxito). Si myAppLogic falla, habrá un 1; si tiene éxito, habrá un 0.

Si la aplicación que queremos hacer es una aplicación existente, utilizando inyección de dependencia o no controla su función principal, entonces podemos crear un sistema para ejecutar sus programas ZIO:

import zio._

object IntegrationExample {

  val runtime = Runtime.default

  Unsafe.unsafe { implicit unsafe =>

    runtime.unsafe.run(ZIO.attempt(println("Hello World!"))).getOrThrowFiberFailure()

  }

}

Idealmente, la aplicación debería tener un solo runtime, porque cada runtime tiene sus propios recursos (incluido el grupo de subprocesos y el informador de errores no controlados).

ZIO proporciona un módulo para interactuar con la consola. Si necesita imprimir texto en la consola, puede usar print e printLine:

import zio._

// Print without trailing line break

Console.print("Hello World")

// Print string and include trailing line break

Console.printLine("Hello World")

Si necesita leer la entrada desde la consola, puede usar readLine:

import zio._

val echo = Console.readLine.flatMap(line => Console.printLine(line))

¡Aprende un poco de Erlang por el bien de todos!

 

Quiero recomendarles este libro, es un poquito viejo pero es gratuito escrito por Fred Hebert. Este libro es ampliamente reconocido como una excelente introducción al lenguaje de programación Erlang. Proporciona una cobertura completa de los conceptos fundamentales de Erlang, desde los conceptos básicos de programación funcional hasta temas más avanzados como concurrencia y distribución.

El libro está estructurado de manera didáctica y utiliza ejemplos prácticos para ayudar a los lectores a comprender los conceptos. También aborda temas importantes en el desarrollo de software en Erlang, como la creación de aplicaciones OTP (Open Telecom Platform) y el manejo de errores.

Dejo link: https://learnyousomeerlang.com/

Getting Started with Go on Google Cloud

Google Cloud y Go deben ser de los temas más buscados en estos tiempos y podes aprender en este curso que te estoy pasando! 

"Getting Started with Go on Google Cloud" es un curso gratuito de google cloud utilizando Go como lenguaje de programación. 

Dejo link: https://www.cloudskillsboost.google/quests/129

Comprehensive Rust 🦀

Quiero recomendarles un sitio para aprender rust, que se llama Comprehensive Rust

El sitio nos dice : 

"Este es un curso de Rust de tres días desarrollado por el equipo de Android. El curso cubre el espectro completo de Rust, desde la sintaxis básica hasta temas avanzados como los genéricos y el manejo de errores. También incluye contenido específico de Android en el último día.

El objetivo del curso es enseñarte Rust. Suponemos que no sabe nada sobre Rust y esperamos:

• Brindarle una comprensión integral de la sintaxis y el lenguaje de Rust.
• Le permite modificar programas existentes y escribir nuevos programas en Rust.
• Mostrar expresiones idiomáticas comunes de Rust."

Dejo el link: https://google.github.io/comprehensive-rust/welcome.html

Test de arquitectura con Roslyn parte 2

Siguiento la idea del post anterior, de testear cosas con roslyn. Vamos a testear que en todo el proyecto, todos los atributos privados comiencen con _ (guión bajo) 

Bueno para esto primero necesitamos 3 dependencias más : 

    <PackageReference Include="Microsoft.Build.Locator" Version="1.5.5" />

    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.5.0" />

    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.MSBuild" Version="4.5.0" />

Locator es para localizar el sdk y las librerías, pienso no estoy muy seguro que tenemos que hacer esto porque estamos en un test (pero corrijanme si estoy equivocado) 

Workspace porque vamos abrir un workspace y msbuild para compilar. (esto esta explicado en este post)

Entonces nuestro test nos queda de la siguiente manera : 

    [Test]

    public async Task The_Field_Private_Should_Start_With_Underscore()

    {

        // Arrange

        string projectPath = @"C:\projects\hat\ArchTestWithRoslyn\test\test.csproj";

        MSBuildLocator.RegisterDefaults();

        using (var workspace = MSBuildWorkspace.Create())

        {

            var project = await workspace.OpenProjectAsync(projectPath);

            var compilation = await project.GetCompilationAsync();

            foreach (var syntaxTree in compilation.SyntaxTrees)

            {

                var nodeRoot = syntaxTree.GetRoot();

                var fields = nodeRoot.DescendantNodes()

                    .OfType<FieldDeclarationSyntax>()

                    .Where(field => field.Modifiers

                                        .Any(modify => 

                                            modify.Kind().Equals(SyntaxKind.PrivateKeyword))

                    && field.Declaration.Variables

                        .Any(aVar => !aVar.Identifier.ValueText.StartsWith("_"))

                    );

                // Assert

                Assert.IsTrue(!fields.Any());

            }

        }

    }

Este test lo que hace es crear un workspace, importar el proyecto (podemos importar soluciones si quisieramos) y luego obtiene el o los arboles sintacticos y luego busca si existe algun atributo privado que no comience con "_".  

Y listo!!