JEP 459: Plantillas de Cadenas en Java

La propuesta de Mejora de Java (JEP) 459, titulada "Plantillas de Cadenas", introduce en Java una nueva funcionalidad que permite la creación de cadenas dinámicas de manera más sencilla y segura. Esta característica, presentada como vista previa en Java 22, complementa las literales de cadena y los bloques de texto existentes al combinar texto literal con expresiones embebidas y procesadores de plantillas para producir resultados especializados. 

Objetivos de JEP 459

• Simplificar la escritura de programas Java: Facilita la expresión de cadenas que incluyen valores calculados en tiempo de ejecución.
• Mejorar la legibilidad: Permite una sintaxis más clara al mezclar texto y expresiones, ya sea en una sola línea o en múltiples líneas.
• Incrementar la seguridad: Al componer cadenas a partir de valores proporcionados por el usuario, se mejora la validación y transformación de las plantillas y sus valores embebidos.
• Mantener flexibilidad: Permite que las bibliotecas de Java definan la sintaxis de formato utilizada en las plantillas de cadenas.
• Simplificar el uso de APIs: Facilita la interacción con APIs que aceptan cadenas escritas en lenguajes no Java, como SQL, XML y JSON. 

Las plantillas de cadenas permiten insertar expresiones directamente dentro de cadenas de texto utilizando una sintaxis específica. A continuación, se muestra un ejemplo básico de su uso:

String nombre = "Duke";

String mensaje = STR."Hola, \{nombre}!";

System.out.println(mensaje);

En este ejemplo, `STR` es un procesador de plantillas que evalúa la expresión embebida `\{nombre}` y la reemplaza con su valor correspondiente, produciendo la salida: "Hola, Duke!". 

Java 22 incorpora varios procesadores de plantillas, entre los que se incluyen:

• STR: Realiza interpolación de cadenas, reemplazando cada expresión embebida con su valor correspondiente convertido a cadena.
• FMT: Similar a STR, pero acepta especificadores de formato como los definidos en java.util.Formatter, permitiendo un formateo más detallado.
• RAW`: No procesa automáticamente la plantilla de cadena, útil para crear procesadores de plantillas personalizados.

Es fundamental tener en cuenta que las plantillas de cadenas fueron introducidas como una funcionalidad en vista previa en Java 21 y reintroducidas en Java 22 con JEP 459. Sin embargo, esta característica fue retirada en Java 23 para una revisión y rediseño adicionales, por lo que no está disponible en versiones posteriores.

Aunque actualmente esta característica está en revisión, su implementación futura promete simplificar y asegurar la construcción de cadenas en Java, facilitando la interacción con otros sistemas y mejorando la legibilidad del código.

Dejo link: https://openjdk.org/jeps/459

JEP 456: Variables y Patrones Anónimos en Java

La Propuesta de Mejora de Java (JEP) 456, titulada "Variables y Patrones Anónimos", introduce en Java la capacidad de declarar variables y patrones sin nombre utilizando el carácter de subrayado (_). Esta característica, incorporada en Java 22, permite a los desarrolladores indicar explícitamente que ciertas variables o parámetros no serán utilizados, mejorando así la claridad y mantenibilidad del código. 

En situaciones donde una variable debe ser declarada pero su valor no es necesario, se puede emplear el carácter _ como nombre de la variable. Esto es útil en contextos como bucles for, bloques catch y expresiones lambda.

Veamos un ejemplo en un bucle for:

int[] numeros = {1, 2, 3, 4, 5};

int total = 0;

for (int _ : numeros) {

    total++;

}

System.out.println("Total: " + total);

En este caso, el bucle itera sobre el array numeros sin necesidad de utilizar el valor de cada elemento, incrementando simplemente el contador total.

Veamos un ejemplo en un bloque catch:

try {

    // Código que puede lanzar una IOException

} catch (IOException _) {

    System.out.println("Ocurrió un error de E/S.");

}

Aquí, se captura la excepción IOException sin necesidad de referenciarla dentro del bloque catch. 

Los patrones anónimos permiten omitir nombres y tipos en patrones de registros cuando no se requiere acceder a ciertos componentes. Esto simplifica la sintaxis y mejora la legibilidad del código al desestructurar objetos.

record Punto(int x, int y) {}

Punto punto = new Punto(5, 10);

if (punto instanceof Punto(int _, int y)) {

    System.out.println("Coordenada y: " + y);

}

En este ejemplo, se omite el nombre de la variable para la coordenada x, ya que no es necesaria, mientras que se accede directamente a la coordenada y. 

La introducción de variables y patrones anónimos en Java 22 representa un avance significativo hacia una sintaxis más concisa y expresiva, alineada con las necesidades modernas de desarrollo.

Librerías estándar de Python

Python cuenta con una extensa biblioteca estándar que proporciona módulos y funciones listas para usar sin necesidad de instalar paquetes adicionales. A continuación, exploramos algunas de las librerías más útiles y cómo utilizarlas.

Manipulación de Archivos y Directorios

os - Interacción con el sistema operativo

import os

print(os.name)  # Nombre del sistema operativo

print(os.getcwd())  # Directorio actual

os.mkdir("nueva_carpeta")  # Crear una carpeta

shutil - Operaciones de archivos y directorios

import shutil

shutil.copy("archivo.txt", "copia.txt")  # Copiar un archivo

shutil.rmtree("nueva_carpeta")  # Eliminar un directorio

Manejo de Fechas y Tiempos

datetime - Fechas y horas

from datetime import datetime

ahora = datetime.now()

print(ahora.strftime("%Y-%m-%d %H:%M:%S"))  # Formateo de fecha

time - Control de tiempo y pausas

import time

time.sleep(2)  # Pausar ejecución por 2 segundos

print("Dos segundos después...")

Operaciones Matemáticas y Estadísticas

math - Funciones matemáticas

import math

print(math.sqrt(25))  # Raíz cuadrada

print(math.pi)  # Valor de PI

random - Generación de números aleatorios

import random

print(random.randint(1, 100))  # Número aleatorio entre 1 y 100

statistics - Cálculos estadísticos

import statistics

datos = [10, 20, 30, 40, 50]

print(statistics.mean(datos))  # Media

print(statistics.median(datos))  # Mediana

Manejo de Datos en Formato Texto

json - Trabajar con JSON

import json

datos = {"nombre": "Emanuel", "edad": 30}

cadena_json = json.dumps(datos)  # Convertir a JSON

print(json.loads(cadena_json))  # Convertir de JSON a diccionario

csv - Lectura y escritura de archivos CSV

import csv

with open("datos.csv", "w", newline="") as archivo:

    escritor = csv.writer(archivo)

    escritor.writerow(["Nombre", "Edad"])

    escritor.writerow(["Emanuel", 30])

Expresiones Regulares y Manejo de Texto

re - Expresiones regulares

import re

texto = "Correo: usuario@example.com"

patron = r"[\w.-]+@[\w.-]+\.\w+"

resultado = re.search(patron, texto)

print(resultado.group())  # usuario@example.com

Concurrencia y Multiprocesamiento

threading - Programación con hilos

import threading

def tarea():

    print("Ejecutando en un hilo")

hilo = threading.Thread(target=tarea)

hilo.start()

multiprocessing - Procesos en paralelo

import multiprocessing

def tarea():

    print("Ejecutando en un proceso")

proceso = multiprocessing.Process(target=tarea)

proceso.start()

Manejo de Errores y Depuración

logging - Registro de eventos y depuración

import logging

logging.basicConfig(level=logging.INFO)

logging.info("Esto es un mensaje informativo")

La biblioteca estándar de Python proporciona herramientas esenciales para diversas tareas sin necesidad de instalar paquetes adicionales. Conocer y utilizar estos módulos puede hacer que tu código sea más eficiente y organizado.

Novedades de java 22

¡JDK 22 ya está disponible!

JDK 22 ofrece 12 mejoras significativas. Estas mejoras abarcan mejoras en el lenguaje Java, sus API, su rendimiento y las herramientas incluidas en el JDK.

1) Mejoras del lenguaje:

• Variables y patrones sin nombre - JEP 456: Mejora la legibilidad cuando se requieren declaraciones de variables o patrones anidados, pero no se utilizan. Ambos se indican con el guión bajo.

1.1) Vistas preview del lenguaje

• Declaraciones antes de super(…) - JEP 447: En los constructores, permite que las declaraciones que no hacen referencia a la instancia que se está creando aparezcan antes de una invocación explícita del constructor.
• Plantillas de cadena (Segunda versión preliminar) - JEP 459: Las plantillas de cadena complementan los literales de cadena y los bloques de texto existentes de Java al combinar el texto literal con expresiones integradas y procesadores de plantillas para producir resultados especializados.
• Clases declaradas implícitamente y métodos principales de instancia (Segunda vista previa) - JEP 463: Los estudiantes pueden escribir sus primeros programas en Java sin necesidad de comprender las características del lenguaje diseñadas para programas grandes. En lugar de usar un dialecto independiente del lenguaje, pueden escribir declaraciones simplificadas para programas de una sola clase y luego ampliarlos sin problemas para usar funciones más avanzadas a medida que mejoran sus habilidades.

2) Bibliotecas

• API de Funciones Externas y Memoria - JEP 454: Permite que los programas Java interoperen con código y datos fuera del entorno de ejecución de Java. Al invocar eficientemente funciones externas (es decir, código fuera de la JVM) y acceder de forma segura a la memoria externa (es decir, memoria no gestionada por la JVM), la API permite que los programas Java invoquen bibliotecas nativas y procesen datos nativos sin la fragilidad ni los riesgos de JNI.

2.1) Vistas previas de bibliotecas e incubadora

• API de archivo de clase (Vista previa) - JEP 457: Proporciona una API estándar para analizar, generar y transformar archivos de clase Java.
• Recolectores de streams (Vista previa) - JEP 461: Mejora la API de streams para admitir operaciones intermedias personalizadas. Esto permitirá que las canalizaciones de flujos transformen datos de maneras que no son fáciles de lograr con las operaciones intermedias integradas existentes.
• Concurrencia estructurada (2.ª vista previa) - JEP 462: Simplifica la programación concurrente. La concurrencia estructurada trata grupos de tareas relacionadas que se ejecutan en diferentes hilos como una sola unidad de trabajo, optimizando así la gestión y cancelación de errores, mejorando la fiabilidad y la observabilidad.
• Valores con Alcance (2.ª Vista Previa) - JEP 464: Permite compartir eficientemente datos inmutables dentro y entre subprocesos.
• API Vector (7.ª Incubadora) - JEP 460: Una API para expresar cálculos vectoriales que se compilan de forma fiable en tiempo de ejecución para obtener instrucciones vectoriales óptimas en arquitecturas de CPU compatibles, logrando así un rendimiento superior al de cálculos escalares equivalentes. Este JEP propone reincubar la API en JDK 22, con mejoras menores en la API con respecto a JDK 21. La implementación incluye correcciones de errores y mejoras de rendimiento. Incluimos los siguientes cambios notables: Compatibilidad con el acceso vectorial con segmentos de memoria del montón respaldados por un array de cualquier tipo de elemento primitivo. Anteriormente, el acceso estaba limitado a segmentos de memoria del montón respaldados por un array de bytes.

3) Rendimiento

• Fijación regional para G1 - JEP 423: Reduce la latencia al implementar la fijación regional en G1, de modo que no es necesario deshabilitar la recolección de elementos no utilizados durante las regiones críticas de la Interfaz Nativa de Java (JNI).

4) Herramientas

Iniciar programas de código fuente con múltiples archivos - JEP 458: Permite a los usuarios ejecutar un programa proporcionado como múltiples archivos de código fuente Java sin tener que compilarlo primero.

Java 22 continúa la evolución del lenguaje, incorporando mejoras que aumentan su expresividad, rendimiento y seguridad. Estas actualizaciones refuerzan el compromiso de la plataforma con la innovación y la adaptabilidad a las necesidades actuales de desarrollo.

En proximos post vamos a detallar las mejoras del lenguaje. 

Dejo link: https://blogs.oracle.com/java/post/the-arrival-of-java-22

Importación de módulos y uso de paquetes en Python

Python es un lenguaje que permite organizar el código en módulos y paquetes, facilitando la reutilización y la modularidad. 

Un módulo en Python es simplemente un archivo `.py` que contiene funciones, clases y variables que pueden ser reutilizadas en otros archivos.

Ejemplo de módulo (`mi_modulo.py`):

Definimos una función en el módulo

def saludar(nombre):

    return f"Hola, {nombre}!"

Para usar un módulo en otro script, se puede importar con import:

import mi_modulo

print(mi_modulo.saludar("Emanuel"))  # Salida: Hola, Emanuel!

También se puede importar solo un elemento específico:

from mi_modulo import saludar

print(saludar("Mundo"))

Si se quiere importar todo el contenido de un módulo pero con un alias:

import mi_modulo as mod

print(mod.saludar("Python"))

Un paquete es una carpeta que contiene múltiples módulos y un archivo especial `__init__.py`, el cual indica que la carpeta debe tratarse como un paquete.

Estructura de un paquete:

mi_paquete/

│── __init__.py

│── modulo1.py

│── modulo2.py

Ejemplo de modulo1.py en mi_paquete:

def sumar(a, b):

    return a + b

Ejemplo de modulo2.py en mi_paquete:

def restar(a, b):

    return a - b

Para importar módulos desde un paquete:

from mi_paquete import modulo1, modulo2

print(modulo1.sumar(5, 3))  # Salida: 8

print(modulo2.restar(10, 4))  # Salida: 6

También se puede importar solo una función específica:

from mi_paquete.modulo1 import sumar

print(sumar(7, 2))

Importación relativa vs. absoluta

- Importación absoluta: Se usa la ruta completa desde el paquete raíz.

 

 from mi_paquete.modulo1 import sumar

- Importación relativa: Se usa `.` o `..` para referirse a módulos dentro del mismo paquete.

 

 from .modulo1 import sumar  # Desde el mismo paquete

 from ..otro_paquete.modulo3 import dividir  # Desde un paquete hermano

Python incluye una gran cantidad de módulos en su biblioteca estándar, que pueden ser importados directamente:

import math

print(math.sqrt(25))  # Salida: 5.0

Para instalar e importar paquetes de terceros (ejemplo: requests):

$ pip install requests

import requests

response = requests.get("https://api.github.com")

print(response.status_code)

El uso de módulos y paquetes en Python permite mantener el código organizado, reutilizable y fácil de mantener. Con las diferentes opciones de importación, puedes estructurar tus proyectos de manera eficiente.