Dynamic Language Runtime

 

Dynamic Language Runtime (DLR) es un entorno de ejecución que agrega un conjunto de servicios para lenguajes dinámicos al Common Language Runtime (CLR). El DLR facilita el desarrollo de lenguajes dinámicos para su ejecución en .NET Framework y la adición de funciones dinámicas a los lenguajes escritos estáticamente.

Los lenguajes dinámicos pueden identificar el tipo de un objeto en tiempo de ejecución, mientras que en lenguajes de tipado estático como C # y Visual Basic (cuando usa Option Explicit On) debe especificar los tipos de objeto en tiempo de diseño. Ejemplos de lenguajes dinámicos son Lisp, Smalltalk, JavaScript, PHP, Ruby, Python, ColdFusion, Lua, Cobra y Groovy.

La mayoría de los lenguajes dinámicos ofrecen las siguientes ventajas para los desarrolladores:

La capacidad de utilizar un ciclo de retroalimentación rápida (REPL o ciclo de lectura-evaluación-impresión). Esto le permite ingresar varias declaraciones y ejecutarlas inmediatamente para ver los resultados.

Soporte tanto para el desarrollo de arriba hacia abajo como para el desarrollo de abajo hacia arriba más tradicional. Por ejemplo, cuando usa un enfoque de arriba hacia abajo, puede llamar a funciones que aún no están implementadas y luego agregar implementaciones subyacentes cuando las necesite.

Refactorización y modificaciones de código más fáciles, porque no tiene que cambiar las declaraciones de tipo estático en todo el código.

Los lenguajes dinámicos son excelentes lenguajes de secuencias de comandos. Los clientes pueden ampliar fácilmente las aplicaciones creadas mediante el uso de lenguajes dinámicos con nuevos comandos y funciones. Los lenguajes dinámicos también se utilizan con frecuencia para crear sitios web y arneses de prueba, mantener granjas de servidores, desarrollar diversas utilidades y realizar transformaciones de datos.

El propósito del DLR es permitir que un sistema de lenguajes dinámicos se ejecute en .NET Framework y brindarles interoperabilidad .NET. El DLR agrega objetos dinámicos a C # y Visual Basic para admitir el comportamiento dinámico en estos lenguajes y permitir su interoperación con lenguajes dinámicos.

El DLR también ayuda a crear bibliotecas que admiten operaciones dinámicas. Por ejemplo, si tiene una biblioteca que utiliza objetos XML o de notación de objetos JavaScript (JSON), sus objetos pueden aparecer como objetos dinámicos en los lenguajes que utilizan DLR. Esto permite a los usuarios de la biblioteca escribir código sintácticamente más simple y natural para operar con objetos y acceder a miembros de objetos.

Al igual que CLR, DLR es parte de .NET Framework y se proporciona con los paquetes de instalación de .NET Framework y Visual Studio. La versión de código abierto del DLR también está disponible para descargar en el repositorio IronLanguages ​​/ dlr en GitHub.

La versión de código abierto del DLR tiene todas las características del DLR que se incluyen en Visual Studio y .NET Framework. También proporciona soporte adicional para implementadores de lenguajes. 

Entre los ejemplos de lenguajes desarrollados mediante el uso de DLR se incluyen los siguientes:

• IronPython. Disponible como software de código abierto en el sitio web de GitHub.
• IronRuby. Disponible como software de código abierto en el sitio web de IronRuby.

El DLR ofrece las siguientes ventajas :

• Simplifica la portabilidad de lenguajes dinámicos a .NET Framework : El DLR permite a los implementadores de lenguaje evitar la creación de analizadores léxicos, analizadores sintácticos, analizadores semánticos, generadores de código y otras herramientas que tradicionalmente tenían que crear ellos mismos. Para utilizar DLR, un lenguaje necesita producir árboles de expresión, que representan código a nivel de lenguaje en una estructura en forma de árbol, rutinas de ayuda en tiempo de ejecución y objetos dinámicos opcionales que implementan la interfaz IDynamicMetaObjectProvider. DLR y .NET Framework automatizan una gran cantidad de análisis de código y tareas de generación de código. Esto permite a los implementadores del lenguaje concentrarse en características exclusivas del lenguaje.
• Habilita funciones dinámicas en lengujes escritos estáticamente : Los lenguajes de .NET Framework existentes, como C # y Visual Basic, pueden crear objetos dinámicos y usarlos junto con objetos de tipo estático. Por ejemplo, C # y Visual Basic pueden usar objetos dinámicos para HTML, Document Object Model (DOM) y reflexión .NET.
• Proporciona beneficios futuros de DLR y .NET Framework : Los lenguajes implementados mediante el uso de DLR pueden beneficiarse de futuras mejoras de DLR y .NET Framework. Por ejemplo, si .NET Framework lanza una nueva versión que tiene un recolector de basura mejorado o un tiempo de carga de ensamblaje más rápido, los lenguajes implementados mediante DLR obtienen inmediatamente el mismo beneficio. Si el DLR agrega optimizaciones, como una mejor compilación, el rendimiento también mejora para todos los idiomas implementados mediante el uso del DLR.
• Permite compartir bibliotecas y objetos : Los objetos y bibliotecas implementados en un idioma pueden ser utilizados por otros idiomas. El DLR también permite la interoperación entre lenguajes dinámicos y de tipado estático. Por ejemplo, C # puede declarar declarar un objeto dinámico que utiliza una biblioteca escrita en un lenguaje dinámico. Al mismo tiempo, los lenguajes dinámicos pueden utilizar bibliotecas de .NET Framework.
• Proporciona Invocación y Despacho Dinámico Rápido: El DLR proporciona una ejecución rápida de operaciones dinámicas al admitir el almacenamiento en caché polimórfico avanzado. El DLR crea reglas para las operaciones vinculantes que utilizan objetos para las implementaciones de tiempo de ejecución necesarias y luego almacena en caché estas reglas para evitar cálculos vinculantes que agotan los recursos durante ejecuciones sucesivas del mismo código en los mismos tipos de objetos.

El DLR agrega un conjunto de servicios al CLR para un mejor soporte de lenguajes dinámicos. Estos servicios incluyen lo siguiente:

Árboles de expresión. El DLR usa árboles de expresión para representar la semántica del lenguaje. Para este propósito, el DLR ha ampliado los árboles de expresión LINQ para incluir el flujo de control, la asignación y otros nodos de modelado del lenguaje. Para obtener más información, consulte Árboles de expresión (C #) o Árboles de expresión (Visual Basic).

Llamadas al almacenamiento en caché del sitio. Un sitio de llamada dinámica es un lugar en el código donde realiza una operación como a + bo a.b () en objetos dinámicos. El DLR almacena en caché las características de ayb (generalmente los tipos de estos objetos) e información sobre la operación. Si tal operación se ha realizado previamente, el DLR recupera toda la información necesaria de la caché para un despacho rápido.

Interoperabilidad de objetos dinámicos. El DLR proporciona un conjunto de clases e interfaces que representan operaciones y objetos dinámicos y pueden ser utilizados por implementadores de lenguaje y autores de bibliotecas dinámicas. Estas clases e interfaces incluyen IDynamicMetaObjectProvider, DynamicMetaObject, DynamicObject y ExpandoObject.

El DLR utiliza carpetas en los sitios de llamadas para comunicarse no solo con .NET Framework, sino también con otras infraestructuras y servicios, incluidos Silverlight y COM. Los aglutinantes encapsulan la semántica de un lenguaje y especifican cómo realizar operaciones en un sitio de llamada mediante árboles de expresión. Esto habilita lenguajes dinámicos y de tipado estático que utilizan el DLR para compartir bibliotecas y obtener acceso a todas las tecnologías que admite el DLR.

ki, la nueva shell para Kotlin

Ki es una nueva shell RELP de Kotlin, la cual trae consigo muchisimas ventajas, en las que podemos nombrar: 

• 
  Autocompletado
• Soporte de dependencias externas
• Soporte de inferencia de tipos
• Modo de pegado especial para pegar fragmentos de código grandes 
• Soporte de secuencias de comandos
• Complementos
• API de Kotlin para compatibilidad con Apache Spark

Cada una de las características se detallan muy bien en el post de Jetbrain, a la vez hay unos GIF con ejemplos de con código y todo. (no puedo superar eso) 

Personalmente me parece una buena idea esto de mejorar las RELP y me parece super útil la interfaz con Spark. 

Dejo link: https://blog.jetbrains.com/kotlin/2021/04/ki-the-next-interactive-shell-for-kotlin

Webinario Introducción al Frontend - Gugler Lab

Te invitamos a participar del Webinario Introducción al Frontend. El mismo se realizará el día Miércoles 31 de Marzo de 19:00 a 20:30 horas.

Hablaremos sobre maquetación web utilizando las últimas novedades de HTML5, CSS3 y frameworks CSS.

El acceso es libre y gratuito.

Para presenciar el evento diríjase al siguiente link: Webinario Introducción al Frontend, ingresando con su nombre y apellido.

Te esperamos !!!

Arquitectura de .NET Framework

Los dos componentes principales de .NET Framework son Common Language Runtime y .NET Framework Class Library.

Common Language Runtime (CLR) es el motor de ejecución que maneja las aplicaciones en ejecución. Proporciona servicios como administración de subprocesos, recolección de basura, seguridad de tipos, manejo de excepciones y más.

La biblioteca de clases proporciona un conjunto de API y tipos para una funcionalidad común. Proporciona tipos de cadenas, fechas, números, etc. La biblioteca de clases incluye API para leer y escribir archivos, conectarse a bases de datos, dibujar y más.

Las aplicaciones .NET están escritas en lenguaje de programación C#, F# o Visual Basic. El código se compila en un Lenguaje Intermedio Común (CIL) independiente del lenguaje. El código compilado se almacena en ensamblados: archivos con una extensión de archivo .dll o .exe.

Cuando se ejecuta una aplicación, CLR toma el ensamblado y usa un compilador just in time (JIT) para convertirlo en código de máquina que se puede ejecutar en la arquitectura específica de la computadora en la que se está ejecutando.

Future en Java

No me voy a poner a hablar del futuro de Java... 

Supongamos que queremos correr un proceso pero por un cierto tiempo, si demora más de ese tiempo debemos lanzar un error y si no retornar el valor. 

Para esto podemos utilizar java.util.concurrent.Future. 

En pocas palabras, la clase Future representa un resultado futuro de un cálculo asincrónico, un resultado que eventualmente aparecerá en el Future una vez que se complete el procesamiento.

Los métodos de ejecución prolongada son buenos candidatos para el procesamiento asincrónico y la interfaz Future. Esto nos permite ejecutar algún otro proceso mientras esperamos que se complete la tarea encapsulada en Future.

Algunos ejemplos de operaciones que aprovecharían la naturaleza asincrónica de Future son:

• Procesos computacionales intensivos (cálculos matemáticos y científicos).
• manipular grandes estructuras de datos (big data)
• llamadas a métodos remotos (descarga de archivos, desguace HTML, servicios web).

Veamos como podemos hacer un Future : 

public class SquareCalculator {    

    

    private ExecutorService executor 

      = Executors.newSingleThreadExecutor();

    

    public Future<Integer> calculate(Integer input) {        

        return executor.submit(() -> {

            Thread.sleep(1000);

            return input * input;

        });

    }

}

En el ejemplo, crearmos una clase muy simple que calcula el cuadrado de un entero. Esto definitivamente no encaja en la categoría de métodos de "ejecución prolongada", pero ponemos una llamada Thread.sleep () para que dure 1 segundo en completarse.

Ya entendido el Future, veamos como nos puede ayudar para ejecutar procesos un cierto tiempo. 

El método get () bloqueará la ejecución hasta que se complete la tarea.  get() tiene una versión sobrecargada que toma un tiempo de espera y un TimeUnit como argumentos:

Integer result = future.get(500, TimeUnit.MILLISECONDS);

Si esto tarda más de 500 milisegundos, se lanzará TimeoutException. Veamos un ejemplo completo: 

// The synchronous method

timeoutFuture = new SquareCalculator().calculate(10);

try {

    timeoutFuture.get(1000, TimeUnit.MILLIS);

} catch (TimeoutException | InterruptedException | ExecutionException e) {

    e.printStackTrace();

}

Y listo! En el catch podemos informar que no termino en el tiempo requerido. 

Lo malo del método get es que es bloqueante y muchas veces no queremos bloquear nuestra ejecución para esperar. Por lo tanto podemos utilizar el método isDone : 

Future<Integer> future = new SquareCalculator().calculate(10);

while(!future.isDone()) {

    System.out.println("Calculating...");

    Thread.sleep(300);

}

Integer result = future.get();

Future, tal vez no es la mejor opción para procesos asincronos complejos pero para estas cositas viene muy bien y es muy fácil de usar. 

Dejo link : https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Future.html

Records en java 16

 

Ya hable de java 16, ahora vamos a ver una de sus mejoras: Records

El objetivo de los records es poder diseñar de forma rápida, tipos de datos compuestos inmutables. Esta característica no viene a remplazar nuestras queridas clases.  

Antes de java 16 debíamos hacer una clase para representar un tipo de dato inmutable, por ejemplo Point : 

class Point {

    private final int x;

    private final int y;

    Point(int x, int y) {

        this.x = x;

        this.y = y;

    }

    int x() { return x; }

    int y() { return y; }

    public boolean equals(Object o) {

        if (!(o instanceof Point)) return false;

        Point other = (Point) o;

        return other.x == x && other.y == y;

    }

    public int hashCode() {

        return Objects.hash(x, y);

    }

    public String toString() {

        return String.format("Point[x=%d, y=%d]", x, y);

    }

}

Ahora podemos utilizar records : 

record Point(int x, int y) { }

Por lo visto, mucho menos código; record nos ofrece metodos y constructores por defecto y por supuesto que podemos sobreescribirlos, un ejemplo sería : 

record SmallPoint(int x, int y) {

  public int x() { return this.x < 100 ? this.x : 100; }

  public int y() { return this.y < 100 ? this.y : 100; }

}

Sin más dejo link: https://openjdk.java.net/jeps/395

Pattern Matching para instanceof en java 16

 

Ya hable de java 16, ahora vamos a ver una de sus mejoras: Pattern Matching para instanceof

Antes de esta característica hacíamos esto : 

if (obj instanceof String) {

    String s = (String) obj;    // grr...

    ...

}

luego de java 16, podemos resolver el casteo de la siguiente manera : 

if (obj instanceof String s) {

    // Y aca usamos s como un string

    ...

}

Dejo link : https://openjdk.java.net/jeps/394

Java 16

Retarde llegue con la noticia pero bueno, nobleza obliga, llego java 16. Ya a esta altura, de casualidad estoy usando java 11. Paren el tren!!! }

Más allá de mi experiencia personal de estos cambios de versiones, vamos a ver que nos trae Java 16. 

338:	Vector API (Incubator)
347:	Enable C++14 Language Features
357:	Migrate from Mercurial to Git
369:	Migrate to GitHub
376:	ZGC: Concurrent Thread-Stack Processing
380:	Unix-Domain Socket Channels
386:	Alpine Linux Port
387:	Elastic Metaspace
388:	Windows/AArch64 Port
389:	Foreign Linker API (Incubator)
390:	Warnings for Value-Based Classes
392:	Packaging Tool
393:	Foreign-Memory Access API (Third Incubator)
394:	Pattern Matching for instanceof
395:	Records
396:	Strongly Encapsulate JDK Internals by Default
397:	Sealed Classes (Second Preview)

A nivel de lenguaje lo más importante son Pattern Matching para instanceof y records (a mi entender). 

Sin más dejo link: https://jdk.java.net/16/

Corre Clojure en .net con ClojureCLR

Supongamos que queremos programar en .net y con Clojure. Y se puede! con ClojureCLR. 

Primero debemos instalarlo, utilizando una terminal con el siguiente comando: 

dotnet tool install --global --version 1.10.0-beta1 Clojure.Main

Hoy estoy en powershell, sería algo así  : 

PS C:\dotnet> dotnet tool install --global --version 1.10.0-beta1 Clojure.Main                                          

You can invoke the tool using the following command: Clojure.Main

Tool 'clojure.main' (version '1.10.0-beta1') was successfully installed.

Y luego, escribimos  Clojure.Main en la terminal y podemos acceder al RELP : 

PS C:\dotnet> Clojure.Main

Clojure 1.10.0-beta1

user=> (defn mayor [L]

  (cond

        (empty? (rest L)) (first L)

        (> (first L) (mayor (rest L))) (first L)

        :else (mayor (rest L))

  )

)

#'user/mayor

user=> (mayor '(1 2 3 50 40))

50

Dejo link :  https://github.com/clojure/clojure-clr

.NET Tutorial - Hello World in 10 minutes

Quiero recomendar esta página que permite aprender .net de forma rápida y bastante interactiva. 

En dicha pagina podemos comenzar de 0 a programar software sencillo. Esta muy bueno, para empezar. 

Dejo link: https://dotnet.microsoft.com/learn/dotnet/hello-world-tutorial/intro

Cursos Gugler : Inscripciones abiertas para el primer cuatrimestre del año 2021

Ya se encuentra disponible el formulario de inscripción a los cursos de extensión que dicta el Laboratorio de Investigación Gugler en modalidad semipresencial y a distancia.

Dejo el link para inscribirse : https://www.gugler.com.ar/

Primeros pasos con Clojure, parte 32

  Seguimos con Clojure... 

Para terminar esta saga de post, vamos a hacer una pequeña función que permita obtener el mayor número de una lista de números. 

(defn mayor [L] 

  (cond 

        (empty? (rest L)) (first L)

        (> (first L) (mayor (rest L))) (first L)

        :else (mayor (rest L))

  )

)

Esta pequeña expresión nos permite saber el mayor de una lista. Su funcionamiento es fácil, si la lista tiene un solo elemento, ese es el mayor y si la lista tiene varios elementos, bueno compara el primero con el mayor del resto de la lista, si es mayor, entonces es el mayor, sino retorna el mayor del resto de la lista. 

Puff espero que se haya entendido... 

Primeros pasos con Clojure, parte 31

 Seguimos con Clojure... 

Clojure provee manejo de excepciones como Java (try/catch/finally), veamos un ejemplo : 

(try

  (/ 2 1)

  (catch ArithmeticException e

    "divide by zero")

  (finally

    (println "cleanup")))

Tambien podemos lanzar excepciones: 

(try

  (throw (Exception. "something went wrong"))

  (catch Exception e (.getMessage e)))

Clojure provee información extra con : 

• ex-info toma un mensaje y un mapa y genera una excepción
• ex-data recupera el mapa generado por ex-info

Veamos un ejemplo : 

(try

  (throw (ex-info "There was a problem" {:detail 42}))

  (catch Exception e

    (prn (:detail (ex-data e)))))

Primeros pasos con Clojure, parte 30

 Seguimos con Clojure... 

Clojure no es un lenguaje funcional puro, por lo tanto tiene funciones con efecto secundario. Vamos a ver algunas : 

dotimes :

user=> (dotimes [i 3]

         (println i))

0

1

2

nil

Muy parecido a un for, empieza de 0 y sigue hasta 3 - 1.

doseq :

user=> (doseq [n (range 3)]

         (println n))

0

1

2

nil

Itera sobre una secuencia (evaluandola si es lazy). Tambien existe la variante que procesa todas las permutaciones del contenido de la secuencia, veamos un ejemplo : 

user=> (doseq [letter [:a :b]

               number (range 3)] ; list of 0, 1, 2

         (prn [letter number]))

[:a 0]

[:a 1]

[:a 2]

[:b 0]

[:b 1]

[:b 2]

nil

for : 

user=> (for [letter [:a :b]

             number (range 3)] ; list of 0, 1, 2

         [letter number])

([:a 0] [:a 1] [:a 2] [:b 0] [:b 1] [:b 2])

La función for se utiliza para generar listas, como listas por comprensión. 

Primeros pasos con Clojure, parte 29

Seguimos con Clojure... 

cond es una serie de condiciones y expresiones. Cada condición se evalúa en orden y la expresión se evalúa y devuelve el resultado de la primera expresión en que condición fue verdadera.

(let [x 5]

  (cond

    (< x 2) "x is less than 2"

    (< x 10) "x is less than 10"))

Si no se cumple ninguna condición, se devuelve nil. Un modismo común es usar una condición final de :else. Las palabras clave (como :else) siempre se evalúan como verdaderas, por lo que siempre se seleccionará de forma predeterminada.

(let [x 11]

  (cond

    (< x 2)  "x is less than 2"

    (< x 10) "x is less than 10"

    :else  "x is greater than or equal to 10"))

case compara un argumento con una serie de valores para encontrar una coincidencia. ¡Esto se hace en tiempo constante (no lineal)! Sin embargo, cada valor debe ser un literal en tiempo de compilación (números, cadenas, palabras clave, etc.).

A diferencia de cond, case arrojará una excepción si ningún valor coincide.

user=> (defn foo [x]

         (case x

           5 "x is 5"

           10 "x is 10"))

#'user/foo

user=> (foo 10)

x is 10

user=> (foo 11)

IllegalArgumentException No matching clause: 11

case puede tener una expresión final que se evaluará si ninguna prueba coincide.

user=> (defn foo [x]

         (case x

           5 "x is 5"

           10 "x is 10"

           "x isn't 5 or 10"))

#'user/foo

user=> (foo 11)

x isn't 5 or 10