También puedes leer este artículo en Medium.

Siempre es divertido ver cómo los lenguajes de programación evolucionan con el tiempo.

Había una vez, cuando comencé mi viaje en el mundo del desarrollo de software, los lenguajes dinámicos como Python, PHP y JavaScript eran apreciados por su flexibilidad y sintaxis concisa adecuada para un desarrollo rápido.

Sin embargo, a medida que estos lenguajes de tipo débil evolucionan, incorporan características de lenguajes de tipo fuerte, lo que los hace muy similares a C y Java:

• Python: capacidades de sugerencia de tipos introducidas desde la versión 3.5 en 2015 y mejoradas en la versión 3.12 en 2022.
• PHP: Tipos declarados introducidos en la versión 7 en 2015.
• JavaScript: Ampliado por el lanzamiento de TypeScript en 2012 definido como "JavaScript con sintaxis para tipos".

¿Por qué este cambio?

En lenguajes de escritura estricta, definimos explícitamente los tipos de variables en nuestro código. El objetivo es detectar los errores durante la fase de desarrollo antes de ejecutar el programa y proporcionar una pista al compilador sobre el tamaño de memoria que se debe asignar a estas variables.

// C   example: 'y' will be an integer
float x = 3.14;
int y = x;  //  y = 3 (ignored the decimal part of the number)

Por otro lado, los lenguajes de tipo dinámico como Python, PHP y JavaScript nos permiten crear variables y dejar que el intérprete implique su tipo durante el tiempo de ejecución:

# In python and PHP: 'y' will take the same type as 'x'
x = 3.14
y = x  // y = 3.14 (float)

¿Cómo se introduce la escritura explícita en los lenguajes dinámicos?

En el siguiente ejemplo, declaramos la misma función usando escritura dinámica y estática.

Pitón:

# using the classic syntax:
def add(x, y):
    return x   y
# using explicit typing:
def add(x: int, y:int) -> int:
    return x   y

JavaScript/TypeScript:

// using the classic syntax
function add(x, y) {
    return x   y;
}
// using explicit typing
function add(x: number, y: number): number {
    return x   y;
}

PHP:

// using the classic syntax:
function add($x, $y) {
    return $x   $y;
}
// using explicit typing:
function add(int $x, int $y): int {
    return $x   $y;
}

PHP 8.2 (lanzado en diciembre de 2022) lo impulsa aún más al introducir la compatibilidad con nulo, verdadero y falso como tipos independientes:

public null $nil = null;
public false $false = false;`

¿Dónde está la ironía?

No tome este artículo como una objeción a estas nuevas características, reconozco las ventajas de usar lenguajes estrictamente tipificados. Sin embargo, usar anotaciones de tipo en Python, por ejemplo, no le impide cambiar los tipos de sus variables:

x: int = 0
x = "John" 
print(type(x))   # 

Lo mismo para PHP, solo imprimirá una advertencia Obsoleta en la consola.

Uno podría preguntarse entonces ¿por qué el intérprete nos permite ejecutar este código?
Esto se debe a que estos lenguajes están construidos de esa manera: se escriben dinámicamente por definición. Si eliminamos esta característica, ya no serán dinámicos; se convertirán en lenguajes estrictamente tipificados como C, pero más lentos.

Con suerte, puedes pedirle a tu intérprete que sea más rígido estableciendo estrictos_tipos en verdadero en tu archivo PHP:

declare(strict_types=1);

Mientras estás en Python, puedes usar el paquete 'mypy' para analizar tu código y detectar errores:

$ mypy program.py
error: Incompatible types in assignment (expression has type "str", variable has type "int")  [assignment]

Puedes ver 'mypy' como un asesor que te indica lo que hiciste mal, pero eso no te impide ejecutar tu código bajo tu responsabilidad.

Incluso si no estás seguro del tipo de variable, aún puedes usar el operador de unión para reducir la lista de tipos aceptados:

Los siguientes ejemplos de PHP y Python muestran cómo hacerlo:

y: int | float = f(x)   # introduced in Python 3.10
int | float $y = f($x)  // introduced in PHP 8.0
let y: number | string  // typescript

¿Estamos sacrificando la legibilidad del código?

Hace diez años, decidí usar Python para mi doctorado debido a su simplicidad y la capacidad de crear prototipos de nuevas ideas rápidamente. Luego comencé a usarlo también para mis otros proyectos.

Ahora, me encuentro leyendo algunos PEP extraños y preguntándome si realmente vale la pena complicar mi código base al incluir estas nuevas características.

Veamos una función de ejemplo que imprime los elementos de un diccionario. Aquí está la versión inicial:

def print_attributes(**kwargs):
    for key, value in kwargs.items():
        print(key, value)

person = {"name": "John", "height": 1.84}
print_attributes(**person)

Al utilizar las recomendaciones de PEP 692 introducidas en Python 3.12, el código se convierte en:

from typing import TypedDict, Unpack

class Person(TypedDict):   # create a class inheriting from TypedDict
    name: str                  
    height: float           

def print_attributes(**kwargs: Unpack[Person]) -> None:  # use the Unpack operator
    for key, value in kwargs.items():
        print(key, value)

person: Person = {"name": "John", "height": 1.84}  # create an instance of the class
print_attributes(**person)

En resumen: creamos una clase que hereda de TypedDict, especificamos el nombre y el tipo de cada elemento y utilizamos el operador Unpack para decirle a "mypy" que el objeto recibido es un TypedDict.

Como resultado, nuestro código duplicó su tamaño. Sería aún más largo si nuestro objeto tuviera más elementos.

Afortunadamente, podemos usar escritura estática para algunas partes de nuestro código y dejar el resto como dinámico. O podemos optar por no usarlo en absoluto si lo preferimos.

¿Cuándo debemos usarlo?

No te sientas presionado a reescribir todo tu código base solo porque aprendiste una característica nueva y brillante.

Estas nuevas funciones son como herramientas. Mi consejo es usarlos sabiamente:

Utilice escritura estática en los siguientes escenarios:

• Al recuperar datos de fuentes externas, como bases de datos, bibliotecas y API.
• En partes críticas de su código donde no se permiten fallas.
• Cuando tu código base es propenso a errores frecuentes.

Evita usar escritura estática cuando estés:

• Diseñando un prototipo para probar rápidamente tu idea.
• Implementar una lógica interna en la que la verificación de tipos solo dará como resultado un código detallado sin beneficios.
• Simplemente mostrar datos en la pantalla (por ejemplo, trazar gráficos, imágenes, números…).
• Escribir un script de línea de comando sin entradas del usuario.

Ten en cuenta que cuando se trata de codificación, la regla de oro es siempre esforzarte por lograr la simplicidad, excepto si tienes una buena razón para complicar las cosas.