Translate

martes, 20 de abril de 2021

Microsoft presenta : Rust para Windows


Microsoft anunció Rust para Windows, que tiene como objetivo permitir la creación de aplicaciones Rust para Windows utilizando cualquier API de Windows.

Rust para Windows tiene como objetivo poner a disposición las API más antiguas y más recientes aprovechando el proyecto win32metadata para crear proyecciones idiomáticas de la API de Windows para lenguajes distintos de C# y F#.

Este framework puede generar enlaces a todas las API de Windows necesarias sobre la marcha. Lo que debemos hacer es especificar qué tipos de API necesitamos dentro de un archivo build.rs:

fn main() {

    windows::build!(

        Windows::Data::Xml::Dom::*,

        Windows::Win32::WindowsProgramming::CloseHandle,

        Windows::Win32::WindowsAndMessaging::MessageBoxA,

        Windows::Win32::SystemServices::{

            CreateEventW, SetEvent, WaitForSingleObject

        },

    );

}

Los enlaces generados se pueden importar y usar en los archivos fuente de Rust:

use bindings::{

    Windows::Data::Xml::Dom::*,

    Windows::Win32::SystemServices::{CreateEventW, SetEvent, WaitForSingleObject, PWSTR},

    Windows::Win32::WindowsAndMessaging::{MessageBoxA, HWND, MESSAGEBOX_STYLE},

    Windows::Win32::WindowsProgramming::CloseHandle,

};

Microsoft ha proporcionado varios programas de muestra que utilizan varias API de Windows, incluidos Direct2D, Microsoft.Web.WebView2.Core, Win2D y otros. 

Win32metadata no solo permite proyecciones automatizadas de API de Windows, sino que también se esfuerza por facilitar su uso al convertir tipos no específicos como uint en enumeraciones específicas, tipos opacos como objetos HANDLE y GDI en estructuras fuertemente tipadas, etc.

La documentación de Rust para todas las API proyectadas también está disponible para describir cómo se proyectan las API y los tipos de Windows en Rust idiomático.

Rust para Windows todavía está en versión preliminar y el proyecto agradece las contribuciones para identificar y corregir errores en el código fuente.

Dejo video : 

Dejo link: https://docs.microsoft.com/en-us/windows/dev-environment/rust/rust-for-windows

lunes, 19 de abril de 2021

NET 6: Date y Time


Un problema de larga data con la biblioteca de clases base de .NET es la incapacidad de representar por separado los valores de fecha y hora. Como parte de .NET 6, las nuevas clases DateOnly y TimeOnly buscan corregir esto.

Avance rápido a .NET 6 y obtenemos la propuesta DateOnly y TimeOnly. Como implican los nombres, estas estructuras están diseñadas para contener solo una fecha o solo una hora. El nombre original de la estructura DateTime era solo Date. Esto continúa en VB, donde la palabra clave Date continúa haciendo referencia a DateTime. Por lo tanto, se eligió el nombre DateOnly para evitar confusiones.

Otra razón por la que se eligió el nombre DateOnly es que DateTime.Date ya devuelve un valor DateTime. Esto no se puede cambiar, pero los nuevos programadores esperan que devuelva una fecha. Al llamar al tipo DateOnly, la nueva propiedad coincidente se puede llamar DateTime.DateOnly.

De manera similar, TimeOfDay es problemático ya que muchas propiedades y métodos lo usan para referirse a un valor de DateTime o TimeSpan.

DateOnly y TimeOnly no implementarán el atributo Serializable. En .NET Core y versiones posteriores, este atributo se considera obsoleto, al igual que las bibliotecas de serialización que dependen de él.

En este momento, no hay planes para abordar escenarios avanzados como el manejo de la zona horaria real y el período frente a la duración. Este rol lo maneja en gran parte la biblioteca Noda Time. Basado en Joda Time de Java, también le permite representar fechas parciales como "3 de enero" o "marzo de 2021", donde el año, el día o el mes faltan intencionalmente.

Dejo link : https://www.infoq.com/news/2021/04/Net6-Date-Time/

domingo, 18 de abril de 2021

Partición de tablas con MariaDb

 


En sistemas grande o viejos sucede que existen tablas muy grandes, son tablas que cuando hacemos un select y tenemos que recorrerlas impacta en la performance. Son las tablas que tratamos de no tocar cuando hay que desarrollar una nueva funcionalidad.

Si utilizamos oracle o postgres o alguna otra base de datos podemos partir estas tablas de modo que la información vieja quede en otras particiones y podamos trabajar con un rango menor de información, mejorando así la performance de nuestro sistema.

Pero MariaDb también permite partir tablas!! (que suerte porque sino este post era al pedo :P ) 

Existen 2 tipo de particiones vertical y horizontal, es decir por filas o columnas.

Vamos a empezar con preguntas frecuentes...

Cuando particionar tablas? Cuando tenes una tabla grande.

Que es grande? Depende del servidor que tengas, de cuanto va a crecer la tabla, etc...

Cuando no esta bueno particionar la tabla? Cuando consultas información vieja todo el tiempo, no vas a ver el cambio, en el caso de particion por fila. Y no es conveniente hacer partición por columna si siempre recupero todas las columnas.

Lo aplico en la base de producción y veo que onda? No seas pavo, lo más conveniente es aplicarlo en un servidor de prueba y probar. Podes jugar con la cantidad de registros de la partición; ver cuales son las tablas que conviene partir. Para esto lo ideal es tener una batería de test de performance y medir, medir y medir... Y al final aplicar en producción.

Como particiono? Buena pregunta, ahora voy a explicar un poco más. Como imaginaran la particiones son por tabla, es decir parto una tabla en n partes, el numero n impacta en la performance por lo tanto hay que elegir el mejor posible y ir probando. Para partir una tabla necesito un criterio de partición; por ejemplo las facturas más viejas a esta fecha se encuentran en una parte; las más viejas que esta otra fecha en otra y así …

MariaDb implementa el particionado horizontal. Básicamente, se pueden realizar cuatro tipos de particionado, que son:

RANGE: la asignación de los registros de la tabla a las diferentes particiones se realiza según un rango de valores definido sobre una determinada columna de la tabla o expresión. Es decir, nosotros indicaremos el numero de particiones a crear, y para cada partición, el rango de valores que serán la condición para insertar en ella, de forma que cuando un registro que se va a introducir en la base de datos tenga un valor del rango en la columna/expresion indicada, el registro se insertara en dicha partición.

LIST: la asignación de los registros de la tabla a las diferentes particiones se realiza según una lista de valores definida sobre una determinada columna de la tabla o expresión. Es decir, nosotros indicaremos el numero de particiones a crear, y para cada partición, la lista de valores que serán la condición para insertar en ella, de forma que cuando un registro que se va a introducir en la base de datos tenga un valor incluido en la lista de valores, el registro se insertara en dicha partición.

HASH: este tipo de partición esta pensado para repartir de forma equitativa los registros de la tabla entre las diferentes particiones. Mientras en los dos particionados anteriores eramos nosotros los que teníamos que decidir, según los valores indicados, a que partición llevamos los registros, en la partición HASH es MariaDb quien hace ese trabajo. Para definir este tipo de particionado, deberemos de indicarle una columna del tipo integer o una función de usuario que devuelva un integer. En este caso, aplicamos una función sobre un determinado campo que devolvera un valor entero. Según el valor, MariaDb insertará el registro en una partición distinta.

KEY: similar al HASH, pero la función para el particionado la proporciona MariaDb automáticamente (con la función MD5). Se pueden indicar los campos para el particionado, pero siempre han de ser de la clave primaria de la tabla o de un índice único.

SUBPARTITIONS: MariaDb permite además realizar subparticionado. Permite la división de cada partición en múltiples subparticiones.

Luego de toda esta teoría solo quedan ganas de partir, de partir tablas! Y se parten así:


CREATE TABLE by_year (

   d DATE

)

PARTITION BY RANGE (YEAR(d))

(

PARTITION P1 VALUES LESS THAN (2001),

PARTITION P2 VALUES LESS THAN (2002),

PARTITION P3 VALUES LESS THAN (2003),

PARTITION P4 VALUES LESS THAN (MAXVALUE)

)

Y listo, la macana es que para particionar una tabla existente, tenemos que crear una nueva y copiar los datos y luego renombrar. 

Dejo link: https://mariadb.com/kb/en/partitioning-tables/

martes, 13 de abril de 2021

Programación poliglota con GraalVM


Una de las características de GraalVM es que podemos programar en diferentes lenguajes. Y esto es gracias a Truffle. 

Truffle es un framwork Java para construir implementaciones de lenguajes de programación como intérpretes para árboles de sintaxis abstractos auto-modificables. Al escribir un intérprete de lenguaje con Truffle, automáticamente usará el compilador GraalVM como un compilador jit (just in time) para el lenguaje. Al tener acceso a este framework, una aplicación Ruby, por ejemplo, puede ejecutarse en la misma JVM que una aplicación Java. Además, un lenguaje host basado en JVM y un lenguaje invitado pueden interactuar directamente entre sí y pasar datos de un lado a otro en el mismo espacio de memoria.

Con el fin de proporcionar valores políglotas en los lenguajes implementados con Truffle, se ha desarrollado el llamado protocolo de interoperabilidad políglota. Este protocolo de interoperabilidad consiste en un conjunto de mensajes estandarizados que cada lenguaje implementa y usa para valores políglotas. El protocolo permite a GraalVM admitir la interoperabilidad entre cualquier combinación de lenguajes sin que sea necesario que se conozcan entre sí. 

En próximos post, vamos a profundizar como ejecutar aplicaciones políglotas con graalvm. 

Dejo link: https://www.graalvm.org/reference-manual/polyglot-programming/



domingo, 11 de abril de 2021

QT 6 soporta C++ 17


The Qt Company ha liberado Qt 6.0, ya hace rato pero me acabo de enterar, si no lo conocen a qt salgan del termo, dado que no solo es la base tecnológica de KDE Plasma y LXQt, sino también de destacadas aplicaciones como VirtualBox, VLC, Shotcut y muchas otras.

Qt 6 ha llegado sobre todo con la intención de adaptar el framework a las tecnologías que han emergido o evolucionado en los últimos tiempos, manteniendo en el proceso sus principales virtudes, que son el desarrollo multiplataforma para escritorio, móviles y sistemas embebidos; la “escalabilidad desde dispositivos de un solo propósito y de gama baja hasta aplicaciones de escritorio complejas de gama alta”; sus API, herramientas y documentación; además de su mantenibilidad, estabilidad y compatibilidad para permitir a los usuarios “mantener grandes bases de código con un mínimo esfuerzo.”

La primera novedad que encontramos es el requerimiento de usar un compilador compatible C++ 17, la última versión del popular lenguaje de propósito general y orientado a objetos. La empresa ha intentado con este movimiento permitir el uso de construcciones de lenguaje C++ más modernas al desarrollar con Qt y puntos de integración en el lado de la API.

En lo que respecta a las bibliotecas principales y las API del framework, Qt 6 incorpora un nuevo sistema de propiedad y binding, mejoras en el soporte de Unicode, la unificación de ‘QList’ y ‘QVector’ en una misma clase y que ahora “‘QMetaType’ y ‘QVariant’ son fundamentales para el funcionamiento del sistema de metaobjetos de Qt”. También se han introducido una gran cantidad de cambios en componentes que no están relacionados con los gráficos, como el hecho de que Qt Concurrent haya “experimentado una reescritura casi completa para hacer que el desarrollo de las aplicaciones multiproceso sea más sencillo que nunca.”

La GPU ha ganado mucho protagonismo durante el transcurso de la última década (2011-2020), y obviamente Qt no iba a quedarse atrás en ese aspecto. Qt 5 se apoyó en su momento en OpenGL para dotarse de características de aceleración por hardware, pero surgió la necesidad de adaptarse mejor a las API propietarias de Microsoft y Apple: DirectX y Metal. En Qt 6 se ha introducido y habilitado por defecto Rendering Hardware Interface (RHI), que es una nueva capa de abstracción para gráficos 3D que se encarga de que Qt Quick se apoye en Direct3D en Windows y en Metal en macOS. Sobre Linux no se comenta de si esta característica ha llegado o no, o si se sigue apoyando en OpenGL o se ha iniciado la transición a Vulkan.

Qt Quick 3D es un módulo relativamente reciente con el que se ha pretendido ofrecer una API con soporte completo para la “creación de escenas complejas en 3D”, todo con la intención de que sea “tan fácil de usar como las partes existentes de Qt Quick” y permitir una integración perfecta entre los contenidos en 2D y en 3D. Qt Quick 3D ha sido mejorado en Qt 6 gracias a la introducción de RHI, la mejora de la integración de los contenidos en 2D y en 3D y la mejora del soporte para glTF2 y la renderización basada en físicas.



Spring + GraalVM = Spring Native


Micronaut y quarkus son frameworks similares a Spring pero con la ventaja de que son mucho más performantes. Estos frameworks utilizan la potencia de GraalVM para ser mucho más performante. Spring habia quedado un tanto desplazado en este nicho de mercado hasta ahora. 

Spring lanzo la primera versión de Spring Native, para convertir las aplicaciones Spring Boot existentes, escritas en Java o Kotlin, en imágenes nativas de GraalVM. Las imágenes nativas de GraalVM son pequeñas, optimizadas y se inician rápidamente. Las compensaciones, sin embargo, son tiempos de compilación más largos y menos optimizaciones de tiempo de ejecución en comparación con la JVM.

Trabajando con el equipo de GraalVM durante los últimos 18 meses, Spring Native actúa como un puente para garantizar que GraalVM comprenda el código Spring Boot tradicional.

Dejo link : https://spring.io/blog/2020/11/23/spring-native-for-graalvm-0-8-3-available-now

viernes, 9 de abril de 2021

Libros Gratuitos de Web Code Geeks

 

 

Bootstrap Programming Cookbook

Bootstrap is a free and open-source collection of tools for creating websites and web applications. It contains HTML and CSS-based design templates for typography, forms, buttons,...

 
 

HTML5 Programming Cookbook

HTML5 is a core technology markup language of the Internet used for structuring and presenting content for the World Wide Web. Its core aims have been to improve the language with support...

 
 

Apache Hadoop Cookbook

Apache Hadoop is an open-source software framework written in Java for distributed storage and distributed processing of very large data sets on computer clusters built from commodity...

 
 

Amazon S3 Tutorial

Amazon S3 (Simple Storage Service) is a web service offered by Amazon Web Services. Amazon S3 provides storage through web services interfaces (REST, SOAP, and BitTorrent). Amazon...

 

martes, 6 de abril de 2021

Ya tenemos la primera versión de Microsoft OpenJDK


 Si!! Totalmente inesperado Microsoft lanzo una implementación de la OpenJDK, es totalmente gratuita de código abierto para linux y windows. 

En Microsoft, han visto un crecimiento creciente en el uso de Java por parte de los clientes en sus servicios en la nube y herramientas de desarrollo. Por lo tanto han trabajado para ampliar y profundizar el soporte de Java para clientes y desarrolladores.

Los binarios de Microsoft Build de OpenJDK para Java 11 se basan en el código fuente de OpenJDK, siguiendo los mismos scripts de compilación utilizados por el proyecto Eclipse Adoptium y probados con la suite Eclipse Adoptium Quality Assurance (incluidas las pruebas del proyecto OpenJDK). Sus binarios para Java 11 han pasado el Kit de compatibilidad técnica de Java (TCK) para Java 11, que se utiliza para verificar la compatibilidad con la especificación de Java 11. Microsoft Build de OpenJDK es un simple reemplazo directo para cualquier otra distribución de OpenJDK disponible en el ecosistema de Java.

Los binarios de Microsoft Build of OpenJDK 11 pueden contener correcciones y mejoras que consideramos importantes para sus clientes o usuarios internos. Es posible que algunos de estos aún no se hayan respaldado formalmente en sentido ascendente y estén claramente indicados en las notas de lanzamiento. Esto nos permite acelerar las mejoras y las correcciones mucho más rápido mientras procedemos a implementar esos cambios en paralelo. Las actualizaciones serán gratuitas y estarán disponibles para que todos los desarrolladores de Java las implementen en cualquier lugar.

Microsoft utiliza una variedad de proyectos Java de código abierto para tareas críticas en Azure para respaldar su infraestructura global, así como para Big Data y sistemas de análisis de registros. Los servicios de back-end de LinkedIn y Yammer se implementan casi por completo en microservicios de Java nativos de la nube distribuidos. Minecraft Java Edition también sigue siendo omnipresente con un ecosistema significativo de mods y una comunidad de modders entusiastas, y aprovechamos Java para ejecutar los servidores detrás de Minecraft Realms.

Azure está experimentando un crecimiento significativo en las cargas de trabajo de Java a través de Azure Spring Cloud, Azure App Service, Azure Functions y Azure Kubernetes Service. En el futuro, y una vez que comiencen a implementar nuevas JVM con Microsoft Build of OpenJDK en Azure, buscarán oportunidades para recomendar mejores optimizaciones para cargas de trabajo basadas en Java en estos servicios.

A finales de este año, Microsoft Build of OpenJDK se convertirá en la distribución predeterminada para Java 11 en los servicios administrados por Azure. Los clientes no tendrán que realizar ninguna tarea de mantenimiento, ya que la transición será fluida y transparente a través de la implementación de aplicaciones. Para todos los demás servicios de Azure, los clientes pueden traer el JDK que elijan, incluido Microsoft Build of OpenJDK. Proporcionaremos más actualizaciones sobre eso en los próximos meses.

Dejo link : https://www.microsoft.com/openjdk

sábado, 3 de abril de 2021

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. 


domingo, 28 de marzo de 2021

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


martes, 23 de marzo de 2021

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. 

sábado, 20 de marzo de 2021

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