Você também pode ler este artigo no Medium.

É sempre engraçado quando vemos como as linguagens de programação evoluem ao longo do tempo.

Há tempos, quando comecei minha jornada no mundo do desenvolvimento de software, linguagens dinâmicas como Python, PHP e JavaScript eram apreciadas por sua flexibilidade e sintaxe concisa, adequada para desenvolvimento rápido.

No entanto, à medida que essas linguagens de tipo fraco evoluem, elas incorporam recursos de linguagens de tipo forte, tornando-as muito semelhantes a C e Java:

• Python: recursos de dicas de tipo introduzidos desde a versão 3.5 em 2015 e aprimorados na versão 3.12 em 2022.
• PHP: tipos declarados introduzidos na versão 7 em 2015.
• JavaScript: estendido pelo lançamento do TypeScript em 2012 definido como "JavaScript com sintaxe para tipos".

Porquê esta mudança?

Em linguagens de tipagem estrita, definimos explicitamente os tipos de variáveis ​​em nosso código. O objetivo é detectar os erros durante a fase de desenvolvimento antes de executar o programa e fornecer uma dica ao compilador sobre o tamanho da memória a ser alocada para essas variáveis.

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

Por outro lado, linguagens de tipo dinâmico como Python, PHP e JavaScript nos permitem criar variáveis ​​e deixar o interpretador sugerir seu tipo durante o tempo de execução:

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

Como a digitação explícita é introduzida em linguagens dinâmicas?

No exemplo a seguir, declaramos a mesma função usando digitação dinâmica e estática.

Python:

# 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 (lançado em dezembro de 2022) vai ainda mais longe, introduzindo o suporte para null, true e false como tipos independentes:

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

Onde está a ironia?

Não tome este artigo como uma objeção a esses novos recursos, reconheço as vantagens de usar linguagens estritamente digitadas. No entanto, usar anotações de tipo em Python, por exemplo, não impede que você altere os tipos de suas variáveis:

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

O mesmo para PHP, ele apenas imprimirá um aviso Deprecated no console.

Pode-se perguntar por que o interpretador nos permite executar esse código então?
Isso porque essas linguagens são construídas dessa forma: elas são digitadas dinamicamente por definição. Se removermos essa característica, elas não serão mais dinâmicas; eles se tornarão linguagens estritamente digitadas como C , mas mais lentas.

Espero que você possa pedir ao seu intérprete para ser mais rígido definindo strict_types como true em seu arquivo PHP:

declare(strict_types=1);

Enquanto estiver em python, você pode usar o pacote 'mypy' para analisar seu código e detectar os bugs:

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

Você pode ver 'mypy' como um consultor dizendo o que você fez de errado, mas isso não o impede de executar seu código por sua conta e risco.

Mesmo que não tenha certeza sobre o tipo de sua variável, você ainda pode usar o operador união para reduzir a lista de tipos aceitos:

Os seguintes exemplos de PHP e Python mostram como fazer isso:

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 a legibilidade do código?

Há dez anos, decidi usar Python em meu doutorado devido à sua simplicidade e à capacidade de prototipar novas ideias rapidamente. Depois comecei a usá-lo também para meus outros projetos.

Agora, me pego lendo alguns PEPs estranhos e me questionando se realmente vale a pena complicar minha base de código incluindo esses novos recursos.

Vejamos um exemplo de função que imprime os itens de um dicionário. Aqui está a versão inicial:

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

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

Usando as recomendações do PEP 692 introduzidas no Python 3.12, o código se torna:

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)

Em resumo: criamos uma classe que herda de TypedDict, especificamos o nome e o tipo de cada item e usamos o operador Unpack para informar ao “mypy” que o objeto recebido é um TypedDict.

Como resultado, nosso código dobrou de tamanho. Ficaria ainda mais longo se nosso objeto tivesse mais itens.

Felizmente, podemos usar digitação estática para algumas partes do nosso código e deixar o resto como dinâmico. Ou podemos optar por não usá-lo, se preferirmos.

Quando devemos usá-lo?

Não se sinta pressionado a reescrever toda a sua base de código só porque você aprendeu um recurso novo e brilhante.

Esses novos recursos são como ferramentas. Meu conselho é usá-los com sabedoria:

Use digitação estática nos seguintes cenários:

• Ao recuperar dados de fontes externas, como bancos de dados, bibliotecas e APIs.
• Em partes críticas do seu código onde falhas não são permitidas.
• Quando sua base de código está sujeita a bugs frequentes.

Evite usar digitação estática quando você estiver:

• Projetar um protótipo para testar rapidamente sua ideia.
• Implementar lógica interna onde a verificação de tipo resultará apenas em código detalhado com e sem benefícios.
• Apenas exibindo dados na tela (por exemplo, plotando gráficos, imagens, números…).
• Escrever um script de linha de comando sem entradas do usuário.

Tenha em mente que quando se trata de codificação, a regra de ouro é sempre esforçar-se pela simplicidade, exceto se você tiver um bom motivo para complicar as coisas.