Linguagens e paradigmas de programação

Uma linha como x = a + b indica um cálculo sem mencionar um registrador do processador. A abstração torna isso possível: uma linguagem oculta detalhes de níveis inferiores para que quem programa possa se concentrar no trabalho que o programa deve fazer.

O que o processador executa

O código de máquina consiste em instruções codificadas como números binários. A arquitetura do conjunto de instruções (ISA) de um processador define suas instruções e suas codificações. x86-64 é comum em PCs e servidores; ARM é comum em celulares, tablets e muitos laptops. Código construído para uma ISA precisa de tradução ou emulação para funcionar em outra.

O sistema hexadecimal torna mais curta a exibição dos bytes de instruções. Em x86-64, B8 01 00 00 00 coloca 1 no registrador EAX. Os bytes 01 D8 somam o valor em EBX ao EAX. Registradores são pequenas posições de armazenamento dentro do processador. Cada instrução realiza uma pequena ação, como mover dados, somar, comparar ou saltar. O ciclo de busca, decodificação e execução executa essas instruções.

Nomes para as mesmas pequenas ações

A linguagem de montagem substitui os bytes das instruções por nomes legíveis chamados mnemônicos. Aquelas duas instruções x86-64 podem ser escritas:

mov eax, 1
add eax, ebx

Um montador converte a linguagem de montagem em código de máquina. Uma linha de instrução comum normalmente produz uma instrução de máquina. Os nomes dos registradores e as instruções ainda pertencem a uma ISA específica, então usar palavras em vez de bytes não torna a linguagem de montagem portável.

Descreva um problema em menos linhas

Uma linguagem de alto nível oferece variáveis, expressões, condições, laços e funções. Python, C, Java e JavaScript permitem descrever operações sem selecionar registradores. Uma instrução normalmente exige várias instruções de máquina. Uma tradução simplificada de x = a + b faria o seguinte:

1. Carregar o valor de a em um registrador.
2. Carregar o valor de b em outro registrador.
3. Somar os valores dos registradores.
4. Armazenar o resultado para x.

Um compilador real pode combinar ou reorganizar esses passos mantendo o comportamento exigido.

O código-fonte de alto nível é mais fácil de ler, alterar e verificar. Um código-fonte C portável pode ser compilado uma vez para um sistema x86-64 e novamente para um sistema ARM. Cada construção ainda precisa do suporte e das bibliotecas corretos do sistema operacional. A portabilidade do código-fonte não torna um executável nativo universal.

Por que os níveis mais baixos ainda importam

A linguagem de montagem continua útil em código de inicialização, algumas rotinas de sistemas operacionais e drivers, pequenos sistemas embarcados e análises de segurança de programas cujo código-fonte não está disponível. Para código de aplicativos comuns, compiladores modernos geralmente produzem código de máquina com desempenho comparável ao da linguagem de montagem escrita à mão.

A mudança para níveis mais altos ocorreu gradualmente. A linguagem de montagem se difundiu no fim da década de 1940 e no início da década de 1950. O sistema A-0 de Grace Hopper, em 1952, ajudou a avançar a tradução automática. A IBM lançou o FORTRAN em 1957; o COBOL veio em 1959, e o Lisp surgiu por volta de 1958–1960. “Alto nível” indica a distância dos detalhes do hardware, não a dificuldade de aprender a linguagem.

Um compilador traduz código-fonte em código-alvo. O alvo pode ser código de máquina nativo ou uma forma intermediária, como bytecode. A compilação antecipada (AOT) acontece antes da execução do programa; a compilação em tempo de execução acontece durante a execução.

Do texto às instruções

Em uma construção antecipada, várias etapas transformam um arquivo-fonte em instruções:

1. A análise léxica divide o texto em unidades léxicas: partes com significado, como nomes, operadores e números.
2. A análise sintática verifica a gramática e constrói uma estrutura que mostra como as partes se encaixam.
3. A análise semântica verifica regras de significado, incluindo declarações e combinações de tipos permitidas.
4. A otimização encontra uma maneira mais eficiente de realizar o trabalho exigido.
5. A geração de código produz as instruções-alvo.

Considere a instrução C total = price * 3;. Suas seis unidades léxicas são total, =, price, *, 3 e ;. Os nomes são identificadores, 3 é um literal inteiro e o ponto e vírgula encerra a instrução. A análise sintática registra que a multiplicação faz parte da atribuição: calcule price * 3 e depois armazene seu valor em total.

Essas etapas têm funções diferentes. Uma sequência de unidades léxicas corretamente escritas ainda pode violar a gramática. Uma instrução gramaticalmente correta ainda pode usar um tipo de maneira incorreta. Encontrar as unidades léxicas não basta para estabelecer que um programa é válido.

Faça o mesmo trabalho com menos recursos

Suponha que o código-fonte contenha seconds_per_day = 60 * 60 * 24. Os fatores são constantes, então o compilador pode multiplicar 60 por 60 para obter 3600 e depois multiplicar por 24 para obter 86400 durante a construção. Ele pode colocar o valor final na saída em vez de repetir a multiplicação em tempo de execução. Isso é dobramento de constantes.

Uma otimização deve preservar o comportamento exigido pela linguagem. Ela não pode substituir um cálculo por outro mais rápido que produza resultados diferentes dos exigidos. O objetivo é reduzir trabalho, tempo ou memória, mantendo o significado do programa.

Reúna as partes

Programas grandes geralmente são construídos a partir de muitos arquivos. Um compilador pode produzir um arquivo objeto para cada arquivo-fonte. Um arquivo objeto contém código traduzido que ainda pode precisar de conexões com outros códigos. Um ligador reúne as partes e resolve chamadas a rotinas de bibliotecas, como funções de impressão ou matemáticas.

O executável resultante é construído para uma plataforma-alvo, incluindo uma ISA e convenções de sistema operacional. O usuário não precisa do compilador antecipado para executá-lo. Bibliotecas compartilhadas ou componentes de execução ainda podem ser necessários.

Entenda o que uma construção bem-sucedida demonstra

Em Java, int count = "five"; falha em uma verificação de tipo antes da execução. Texto não pode inicializar essa variável inteira. O programa deve passar pelas verificações exigidas em tempo de compilação antes que uma versão executável esteja disponível.

Outras falhas sobrevivem à compilação. A divisão por um zero informado pelo usuário depende dos dados em tempo de execução. Um programa que deveria subtrair, mas soma, pode ser executado e retornar o valor errado. A compilação verifica as regras da linguagem; os testes também devem verificar se o resultado corresponde à tarefa pretendida.

Um programa não precisa se tornar um executável nativo antes de o usuário iniciá-lo. Um interpretador executa o programa por meio de outro programa em execução. Muitas implementações combinam interpretação com compilação, então a pergunta útil é como esse sistema específico executa o código.

Execute por meio de um interpretador

Um interpretador precisa estar disponível sempre que executar o programa. Um REPL interativo repete quatro ações: ler uma entrada, avaliá-la, imprimir um resultado e repetir o ciclo para a próxima entrada. Ele oferece retorno rápido ao experimentar pequenas expressões.

Interpretar não significa necessariamente ler o código-fonte bruto uma linha de cada vez. O CPython, a implementação padrão do Python, primeiro compila um arquivo em bytecode. Uma máquina virtual de software executa então essas instruções internas. O bytecode pertence àquele ambiente de execução; ele não é o conjunto de instruções nativo do processador.

Por que alguns erros aparecem antes

Compare dois arquivos Python. Este tem sintaxe válida:

print("start")
x = 10
print(x + "5")

Ele imprime “start”, associa x a 10 e então gera TypeError. Somar esse inteiro a uma cadeia de caracteres falha apenas quando a expressão é executada. Uma operação semelhante em um ramo não percorrido pode passar despercebida até que o ramo seja executado.

Agora remova o parêntese de fechamento da última linha. O CPython não consegue compilar o arquivo porque sua sintaxe está incompleta. Ele informa um erro de sintaxe antes de qualquer instrução do arquivo ser executada, então “start” não é impresso. A verificação de sintaxe do arquivo inteiro e a verificação em tempo de execução de uma operação executada acontecem em momentos diferentes.

Compartilhe bytecode, especialize durante a execução

Java mostra um caminho híbrido comum. javac Hello.java produz Hello.class, que contém bytecode. java Hello inicia uma máquina virtual Java (JVM) compatível. Diferentes implementações de JVM permitem executar esse bytecode em diferentes famílias de processadores. O bytecode é portável entre ambientes de execução compatíveis; cada ambiente precisa funcionar em sua própria plataforma hospedeira. C# também tem como alvo uma linguagem intermediária usada pelo .NET.

Um compilador em tempo de execução (JIT) gera código de máquina enquanto o programa é executado. O ambiente de execução HotSpot de Java costuma começar com interpretação e compila métodos usados com frequência. Mecanismos JavaScript de navegadores também combinam técnicas de execução, incluindo compilação JIT. Compilar as partes mais usadas pode melhorar a velocidade sustentada, mas consome tempo e memória durante a execução.

Um laço que soma um bilhão de valores geralmente é executado muito mais rápido em C compilado do que no CPython: o CPython realiza trabalho de interpretação e verificações de tipo em torno de muitas operações. Para um script que renomeia 20 arquivos, o esforço de desenvolvimento pode importar muito mais que essa diferença. Meça a carga de trabalho antes de usar a classificação de uma linguagem para prever sua velocidade.

Compilado e interpretado descrevem escolhas de implementação. O CPython usa interpretação de bytecode; o PyPy usa técnicas JIT. Uma linguagem pode ter mais de uma implementação, e uma implementação pode usar vários métodos de execução.

A sintaxe estabelece as regras para um texto de programa válido. A semântica dá significado a esse texto. Um programa pode seguir todas as regras gramaticais e ainda calcular o resultado errado, então verificar sua aparência é apenas a primeira parte de sua leitura.

Reconheça as partes e a gramática

As unidades léxicas incluem palavras-chave como if, identificadores como total, literais como 3 ou "hello", operadores como + e == e sinais de pontuação. Uma gramática descreve como essas partes podem formar expressões e instruções.

Python exige dois-pontos após if x > 3: e usa a indentação para marcar as instruções controladas por essa condição. C, Java e JavaScript usam chaves para blocos; C e Java também exigem ponto e vírgula após muitas instruções. Nessas linguagens, a indentação ajuda a pessoa que lê, mas não seleciona o bloco.

Sintaxes diferentes podem expressar uma ação semelhante. Estas instruções imprimem uma saudação:

print("hello")

printf("hello\n");

System.out.println("hello");

A sequência de escape \n em C acrescenta uma quebra de linha. Conhecer a ideia de impressão ajuda a aprender a forma de expressá-la em cada linguagem.

Os mesmos símbolos podem significar coisas diferentes

A aparência familiar de um símbolo não determina seu significado em todas as linguagens.

A ordem de avaliação também importa. A precedência faz a multiplicação e a divisão acontecerem antes da adição. Com a = 4 e b = 6, average = a + b / 2 divide 6 por 2 primeiro e depois soma 4, produzindo 7,0. Os parênteses em average = (a + b) / 2 fazem a soma acontecer primeiro e resultam em 5,0.

Diferencie os erros

Um erro de sintaxe desrespeita a gramática, como a falta de dois-pontos em Python. Um erro em tempo de execução ocorre durante uma operação executada, como uma divisão por zero em Python. Um erro de lógica permite a execução, mas fornece uma resposta não pretendida, como no cálculo incorreto da média.

Algumas expressões válidas pulam uma operação deliberadamente. Em Python, x != 0 and 10 / x > 2 usa avaliação de curto-circuito. Quando x é zero, a primeira condição é falsa, então o lado direito não é avaliado e nenhuma divisão ocorre. Inverter essas condições eliminaria essa proteção. Python escreve and, or e not; C, Java e JavaScript usam &&, || e !.

Atribuição e comparação são outra distinção importante. = armazena um valor; == testa a igualdade. C permite if (x = 5): ele atribui 5 e trata esse valor diferente de zero como verdadeiro. Python rejeita if x = 5: como sintaxe inválida. O mesmo erro pode, portanto, ser detectado em etapas diferentes em linguagens diferentes.

Um programa curto é mais fácil de entender quando você acompanha uma instrução executada de cada vez. Mantenha os valores atuais visíveis em vez de saltar da primeira linha para um resultado presumido.

Expressões e atribuições

Uma expressão produz um valor: price * 3, x > 10 e len(name) são exemplos. Uma instrução realiza uma ação, como atribuir um valor ou controlar um bloco. Em total = price * 3, a expressão à direita é avaliada antes de seu resultado ser atribuído a total.

Uma variável é um nome que se refere a um valor. A atribuição dá ao nome seu valor atual; ela não é uma afirmação matemática de que os dois lados sempre foram iguais. Se count contém 4, count = count + 1 primeiro lê 4, soma 1 e associa count a 5.

Acompanhe a próxima instrução executada

Três estruturas organizam o fluxo de controle:

• A sequência executa instruções em ordem.
• A seleção usa uma condição para escolher um caminho, como em if e else.
• A iteração repete um bloco com um laço for ou while.

O teorema do programa estruturado, associado a Böhm e Jacopini em 1966, mostra que essas estruturas podem expressar qualquer algoritmo. Um laço for geralmente percorre os elementos de uma coleção. Um laço while se repete enquanto sua condição permanece verdadeira.

Considere este laço em Python:

total = 0
for n in [3, 8, 5]:
    total = total + n

A atribuição indentada é executada uma vez para cada elemento. Uma tabela de rastreamento registra o estado após cada atualização:

Cada novo total usa o anterior. Reiniciar total dentro do laço produziria um cálculo diferente, pois as somas anteriores seriam perdidas.

Entre em uma função e saia dela

Uma função agrupa uma tarefa sob um nome. Um parâmetro é um nome na definição; um argumento é um valor fornecido por uma chamada:

def area(width, height):
    return width * height

result = area(3, 4)

A chamada associa width a 3 e height a 4. A multiplicação produz 12, e return o envia a quem chamou a função. A execução continua na atribuição, então result recebe 12. Os nomes descrevem uma tarefa que pode ser reutilizada com outros argumentos.

Um nome tem um escopo

O escopo determina onde um nome pode ser usado. Nomes criados dentro de uma função normalmente são locais àquela chamada. Um nome no nível superior é global em seu módulo. Chamadas separadas têm associações locais separadas, mesmo quando usam nomes idênticos.

count = 7

def reset():
    count = 0

reset()
print(count)

Isso imprime 7. A atribuição dentro de reset cria um count local; ela não substitui a associação global. Uma função pode, em vez disso, retornar um resultado e deixar que quem a chamou atribua esse resultado.

Escopo e tempo de vida respondem a perguntas diferentes. Um nome local não fica disponível para código externo apenas porque o objeto ao qual se referia ainda existe. Objetos retornados podem permanecer ativos, e uma função aninhada retornada pode manter acesso a variáveis da chamada que a contém; esse ambiente preservado faz parte de um fechamento.

Um tipo de dado especifica os valores possíveis e as operações permitidas sobre eles. Um inteiro permite operações aritméticas com números inteiros; um valor booleano representa verdadeiro ou falso. Cadeias de caracteres, listas, registros e objetos combinam ou organizam outros valores. Os tipos também orientam a representação dos valores na memória, embora o tamanho de um valor possa depender do próprio valor e da implementação.

Quando os tipos são verificados?

Em Python, count = 5 seguido de count = "five" é válido. O nome agora se refere a uma cadeia de caracteres. Avaliar count + 1 em seguida gera TypeError. A tipagem dinâmica dá tipos definidos aos valores; ela não elimina os tipos.

A tipagem estática não exige uma indicação de tipo visível em cada variável. A inferência de tipos permite que um compilador deduza um tipo a partir do código ao redor. Kotlin infere um inteiro para val n = 5, e Rust pode inferir um inteiro para let n = 5;. As anotações de tipo opcionais do Python são diferentes: ferramentas separadas, como o mypy, podem verificá-las, mas a execução comum do Python não as impõe.

Quando os valores são convertidos?

O momento da verificação e o rigor da conversão são questões separadas. Python rejeita "3" + 4; a conversão explícita em int("3") + 4 resulta em 7. JavaScript aplica regras de conversão automática diferentes para operadores diferentes:

• "3" + 4 resulta na cadeia de caracteres "34".
• "3" * 4 resulta no número 12.
• "3" - 4 resulta no número -1.

A conversão automática é chamada de coerção de tipos. Os rótulos tipagem “forte” e “fraca” são formas informais de discutir o rigor da conversão, não outros nomes para tipagem estática e dinâmica. Python é dinâmica e estrita quanto à adição de tipos mistos acima; C é estática e ainda permite muitas conversões numéricas implícitas.

O input() do Python retorna uma cadeia de caracteres. Se uma pessoa digita “30”, o resultado ainda tem o tipo str. age + 1 falha, enquanto int(age) + 1 resulta em 31 quando age contém esse texto. O que aparece na tela não basta para determinar o tipo.

Números têm limites de representação

Um inteiro com sinal de 32 bits representa valores de −2.147.483.648 até 2.147.483.647. O int de Java retorna ciclicamente do máximo ao mínimo quando 1 é somado. O estouro de inteiro com sinal em C é um comportamento indefinido, então não se deve presumir o mesmo retorno cíclico em C. Inteiros em Python crescem conforme a memória permite: 2 ** 100 é exatamente 1.267.650.600.228.229.401.496.703.205.376.

Números de ponto flutuante representam a maioria das frações decimais de forma aproximada em binário. Em Python e JavaScript, 0.1 + 0.2 produz 0.30000000000000004. Comparar esse resultado diretamente com 0.3 resulta em falso.

Quando um cálculo permite um pequeno erro, compare os valores usando uma tolerância escolhida para a tarefa, por exemplo abs(a - b) < 1e-9. Uma tolerância absoluta tão pequena é adequada apenas a algumas escalas. Para cálculos contábeis decimais exatos, use quantidades inteiras da menor unidade ou um tipo decimal adequado. Alterar a comparação não pode tornar exata uma representação aproximada.

A memória principal armazena os dados de um programa em execução. Cada byte tem um endereço. As linguagens oferecem nomes para que quem programa possa trabalhar com valores sem escrever endereços brutos para cada operação.

Chamadas usam registros de ativação; objetos têm tempos de vida

Em C, um int geralmente ocupa 4 bytes, e &x obtém o endereço de x. Linguagens de nível mais alto frequentemente ocultam endereços por trás de referências. A distinção importante é entre uma associação que nomeia um objeto e o próprio objeto.

A pilha de chamadas acompanha as chamadas de funções ativas. Cada chamada tem um registro de ativação com informações como parâmetros, associações locais e o ponto em que a execução deve continuar após o retorno. Se main chama area(3, 4), um registro de area é adicionado acima do registro de quem chamou a função. A função calcula 12, retorna e seu registro é removido. Em chamadas aninhadas comuns, a chamada mais recente retorna primeiro.

A recursão acrescenta uma chamada para cada nível ainda não concluído. Se as chamadas continuam se acumulando, o espaço disponível na pilha pode se esgotar. Python normalmente gera RecursionError após aproximadamente 1.000 chamadas aninhadas, com um limite que depende de suas configurações. Uma condição de parada precisa ser alcançada para que um cálculo recursivo finito termine.

A área de alocação dinâmica contém objetos alocados dinamicamente, como uma lista que cresce ou um objeto que dura mais que a função que o criou. A alocação reserva armazenamento. Uma lista retornada pode permanecer nessa área depois que a chamada que a criou terminou.

Copiar uma referência compartilha um objeto

Uma referência identifica um objeto. Um ponteiro em C ou C++ representa explicitamente um endereço usado para acessar dados. Copiar uma referência copia o acesso ao objeto, não todos os dados do objeto.

a = [1, 2]
b = a
b.append(3)

Após a primeira linha, há uma lista. A segunda linha associa outro nome a ela. A última linha altera essa lista, então tanto a quanto b mostram [1, 2, 3]. Esse compartilhamento é o compartilhamento por referências. Usar b = a.copy() criaria uma lista externa separada; para essa lista de inteiros, acrescentar um elemento à nova lista deixaria a inalterada.

Compare atribuição com mutação:

x = 5
y = x
y = y + 1

O inteiro 5 é imutável. A adição produz 6, e apenas y é associado a outro valor. x ainda se refere a 5. Números, cadeias de caracteres e tuplas em Python são imutáveis; listas e dicionários são mutáveis. O conteúdo fixo de uma tupla pode incluir uma referência a uma lista mutável, então a imutabilidade do contêiner externo não torna imutável todo objeto aninhado.

Aplique as mesmas regras aos argumentos

Quando Python passa uma lista a uma função, o parâmetro se refere ao mesmo objeto. Chamar items.append(4) dentro da função altera essa lista. Atribuir items = [] associa apenas o nome local do parâmetro a uma nova lista. O nome de quem chamou a função continua associado ao objeto original.

C passa os valores dos argumentos por valor. Para permitir que uma função atualize a variável de quem a chamou por meio de seu endereço, passe um ponteiro para ela. Em cada linguagem, faça duas perguntas separadas durante o rastreamento: “A qual objeto este nome se refere?” e “Esta operação altera esse objeto ou associa um nome a outra coisa?”.

A memória alocada precisa, em algum momento, voltar a ficar disponível para uso. O desafio é liberar os dados após seu último uso e manter todos os objetos de que o programa ainda precisa. As linguagens atribuem essa responsabilidade a quem programa, a um sistema de execução ou a regras de propriedade verificadas pelo compilador.

Gerenciamento manual e suas falhas

Em C, malloc(n) solicita n bytes e retorna um ponteiro para o bloco se a operação for bem-sucedida. free(p) libera um bloco obtido por alocação. Quem programa deve usá-lo no momento certo e exatamente uma vez. C++ também permite o gerenciamento manual, embora suas ferramentas padrão possam automatizar a liberação por meio dos tempos de vida dos objetos.

Vários erros têm causas diferentes:

Um ponteiro que continua se referindo a armazenamento liberado é pendente. O armazenamento pode ser reutilizado para outra coisa, então acessá-lo pode corromper dados ou causar uma falha no programa.

Para um array C int scores[10], as posições válidas vão de 0 a 9. Escrever em scores[10] ultrapassa o array, e C não oferece verificação automática de limites. Python gera IndexError quando o índice 10 é usado em uma lista de dez elementos, impedindo que esse acesso sobrescreva a memória adjacente.

Rastreie o alcance ou conte referências

Um coletor de lixo por rastreamento começa por raízes ativas, como referências ativas, segue ligações entre objetos e pode recuperar objetos inalcançáveis. Java, C#, Go e JavaScript usam abordagens por rastreamento. A coleta exige trabalho e memória em tempo de execução; dependendo do coletor, ela pode introduzir pausas.

A contagem de referências acompanha as referências a um objeto. Para uma lista Python recém-criada, a sequência simplificada é: a = [1, 2] fornece uma referência; b = a fornece uma segunda; del a remove uma; b = None remove a outra. O CPython normalmente recupera essa lista comum quando sua contagem chega a zero.

Um grupo de objetos pode manter as contagens uns dos outros acima de zero mesmo quando nenhuma parte ativa do programa consegue alcançar o grupo. Isso é um ciclo de referências. O CPython complementa a contagem de referências com a coleta de ciclos. Tanto a contagem de referências quanto o rastreamento são técnicas automáticas de gerenciamento de memória.

Verifique a propriedade antes da execução

Rust dá a cada valor um proprietário e verifica regras para o empréstimo de referências. Quando a propriedade termina, o código de limpeza gerado libera o valor. Rust seguro rejeita usos de referências que poderiam durar mais que o alvo válido, sem exigir um coletor de lixo por rastreamento. Swift usa contagem automática de referências inserida pelo compilador.

A segurança de memória importa além das falhas de programas. A Microsoft informou em 2019 que aproximadamente 70% das vulnerabilidades às quais atribuía CVEs a cada ano envolviam segurança de memória; o Chromium informou uma proporção semelhante de erros graves em 2020. Em dezembro de 2023, CISA, NSA, FBI e parceiros internacionais recomendaram que fabricantes de software planejassem transições para linguagens seguras quanto à memória.

A recuperação automática ainda mantém objetos alcançáveis. Uma lista global que cresce continuamente pode manter todos os registros antigos ativos mesmo depois que a aplicação terminou de usá-los. Um coletor não consegue decidir que esses registros alcançáveis se tornaram desnecessários para a tarefa; o programa precisa deixar de retê-los.

Um paradigma de programação é uma forma de organizar código e pensar sobre computação. Na programação imperativa, um programa fornece comandos que alteram seu estado: os valores atualmente mantidos por variáveis e objetos.

Torne visíveis as mudanças de estado

Um total acumulado é um cálculo imperativo simples:

total = 0
for n in [3, 8, 5]:
    total = total + n

O estado inicial é total = 0. Somar 3 o altera para 3. Somar 8 o altera para 11. Somar 5 o altera para 16. Cada atribuição usa o estado deixado pelo passo anterior, então a ordem faz parte do método.

Esse estilo corresponde às alterações passo a passo que o processador faz em registradores e memória. Ele também se adapta a algoritmos que atualizam uma coleção deliberadamente no próprio local, como uma rotina de ordenação que troca elementos.

Dê nomes às tarefas

A programação procedural organiza código imperativo em funções ou procedimentos. Um programa de relatórios pode chamar read_scores(), average(scores) e print_report(avg). Os nomes permitem que a pessoa veja a tarefa geral sem acompanhar todas as linhas internas de uma vez. Cada procedimento pode ser entendido e testado separadamente.

C, Pascal, Fortran e COBOL são linguagens procedurais clássicas. Python também oferece suporte a esse estilo: um script pode usar funções nomeadas sem definir nenhuma classe.

A programação estruturada organiza o fluxo de controle com sequência, seleção, laços e chamadas de procedimentos. Ela evita saltos arbitrários que tornam difícil prever a próxima instrução executada. A carta de Edsger Dijkstra de 1968, “Go To Statement Considered Harmful”, ajudou a popularizar essa abordagem. Saídas controladas como break, continue e return continuam úteis: elas permitem sair de uma iteração de laço, de um laço ou de uma função definidos.

Efeitos podem ir além de um valor de retorno

Um efeito colateral altera algo além do resultado retornado por uma função. Imprimir, salvar um arquivo, enviar uma mensagem pela rede e alterar dados compartilhados são efeitos colaterais. Programas precisam dessas ações para interagir com o mundo.

Problemas surgem quando códigos não relacionados alteram silenciosamente o mesmo estado. Suponha que apply_discount() reduza uma variável global price em 10%, e que add_shipping() acrescente 5. Partindo de 100, aplicar o desconto primeiro resulta em 90, e depois acrescentar o frete resulta em 95. Acrescentar o frete primeiro resulta em 105, e depois aplicar o desconto resulta em 94,5. Ambos os procedimentos realizam seus próprios passos corretamente, mas o resultado combinado depende de sua ordem.

Passar valores e retornar novos resultados pode tornar essa ordem visível:

price = add_shipping(apply_discount(100))

A chamada interna é executada primeiro: desconto, depois frete. Um aninhamento diferente expressa uma regra diferente. Um fluxo de dados claro ajuda a revelar se o próprio frete deve receber o desconto.

Código imperativo ainda é comum dentro de métodos de objetos e tratadores de eventos modernos. Escolher um projeto mais amplo orientado a objetos ou funcional não impede que uma pequena parte use comandos diretos quando esses passos tornam o algoritmo claro.

A programação orientada a objetos (OOP) modela um programa como objetos que cooperam entre si. Cada objeto combina dados com operações sobre esses dados. Uma conta pode conter seu titular e saldo, oferecendo operações de depósito e saque.

Separe o modelo de suas instâncias

Uma classe define os atributos e métodos oferecidos por seus objetos. Um objeto, ou instância, é um elemento específico dessa classe. BankAccount é o modelo; a conta de Ana com 150 e a conta de Ben com 40 são instâncias distintas. Seus saldos podem mudar independentemente.

Um atributo armazena dados associados a um objeto. Um método é uma operação chamada por meio de um objeto, como acct.deposit(50). self em um método de instância Python se refere ao objeto que recebe a chamada.

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self._balance = self._balance + amount

Chamar BankAccount("Ana", 100) constrói uma nova instância. Seu método __init__ inicializa os dados da instância. Um construtor é o processo de preparação de um novo objeto; Python separa a criação dessa etapa de inicialização. Chamar acct.deposit(50) nessa conta altera seu saldo de 100 para 150.

Coloque a regra no ponto de atualização

O encapsulamento reúne dados e as operações que mantêm suas regras. Suponha que uma conta nunca deva ter saldo negativo. O método de saque verifica a alteração proposta antes de realizá-la:

def withdraw(self, amount):
    if amount <= 0:
        raise ValueError("amount must be positive")
    if amount > self._balance:
        raise ValueError("insufficient funds")
    self._balance = self._balance - amount

Esse método pertence a BankAccount. Partindo de um saldo de 150, withdraw(200) gera um erro e mantém 150. withdraw(30) é bem-sucedido e deixa 120. A chamada que falha não subtrai primeiro para depois descobrir o problema; a verificação acontece antes da atualização.

Outros códigos devem usar esses métodos em vez de atribuir um saldo sem verificação. Java e C# podem restringir o acesso direto com private. O sublinhado inicial de Python em _balance indica um detalhe interno por convenção; ele não impõe privacidade.

A ocultação de informação vai além: quem chama depende das operações oferecidas por uma classe sem precisar conhecer sua representação interna. O saldo poderia ser armazenado de outra forma posteriormente, enquanto as operações públicas de depósito e saque manteriam seu significado.

Deixe o problema sugerir responsabilidades

Um sistema de biblioteca tem livros, membros e empréstimos. Esses substantivos sugerem possíveis classes ou atributos; ações como emprestar e renovar sugerem métodos. Escolha uma responsabilidade clara para cada classe. Uma classe de conta que também envia todos os e-mails e formata todos os relatórios se torna mais difícil de alterar porque trabalhos não relacionados estão misturados.

Classes e objetos surgiram em Simula 67 em 1967; Smalltalk ajudou a difundir a abordagem na década de 1970. Java, C#, C++ e Python oferecem suporte à programação orientada a objetos, mas usar uma dessas linguagens não obriga que todo programa use classes. A pergunta útil de projeto é quais dados e regras pertencem ao mesmo lugar.

Objetos muitas vezes precisam compartilhar operações e, ao mesmo tempo, diferir em detalhes. Herança, polimorfismo e composição resolvem partes diferentes desse problema de projeto.

Especialize um tipo existente de objeto

A herança define uma subclasse a partir de uma superclasse. Em Python, class SavingsAccount(BankAccount): dá à classe especializada acesso ao comportamento herdado da conta. Ela pode acrescentar add_interest(rate): um saldo de 1.000 com acréscimo de juros de 2% se torna 1.020.

A relação pretendida é de tipo. Uma conta de poupança ainda é uma conta bancária e deve respeitar as regras esperadas de contas bancárias. Reutilizar algumas linhas não é razão suficiente para afirmar que um tipo de objeto é outro.

Uma subclasse pode sobrescrever um método com sua própria implementação. Suponha que uma conta corrente cobre uma tarifa de 1 por cada saque bem-sucedido. Com saldo de 100, sacar 30 custa 31 e deixa 69. Para preservar a regra da conta, o método deve verificar o saque mais a tarifa antes de alterar o saldo. Se esse custo combinado exceder o saldo, ele recusa toda a operação.

Faça uma chamada funcionar com objetos diferentes

O polimorfismo permite que a mesma operação funcione com tipos de objetos diferentes. Um círculo e um retângulo podem oferecer area():

for shape in shapes:
    print(shape.area())

O laço não precisa de um if para cada classe de forma. Cada objeto fornece sua própria implementação. Selecionar essa implementação durante a execução é o despacho dinâmico.

Para Circle(2), a área é de cerca de 12,57 unidades quadradas. Para Rectangle(3, 4), é de 12 unidades quadradas. A área combinada é de cerca de 24,57 unidades quadradas. Uma classe Triangle acrescentada depois pode integrar a coleção ao oferecer uma operação area() compatível; o próprio laço não precisa de outro ramo.

Uma interface declara as operações que um tipo deve oferecer. interface Shape { double area(); } em Java exige que as classes que a implementam forneçam o método de área. Uma classe abstrata pode fornecer parte da implementação compartilhada e deixar outros métodos para as subclasses. Python costuma usar tipagem por comportamento: um objeto pode funcionar no laço se oferecer a operação exigida, mesmo sem uma superclasse compartilhada.

Mantenha uma parte em vez de se tornar ela

A composição armazena outros objetos como partes. Um carro tem um motor e rodas. Ele pode chamar o método start() de seu motor sem herdar de Engine.

Cadeias profundas de herança podem espalhar os efeitos de uma alteração em uma superclasse por muitas classes. Uma subclasse que precisa desativar um comportamento herdado pode indicar uma relação de tipo inadequada. A composição muitas vezes mantém essas dependências menores e mais claras.

Os quatro pilares da programação orientada a objetos comumente citados se encaixam aqui: o encapsulamento protege dados por meio de operações, a abstração oculta detalhes de implementação, a herança especializa um tipo e o polimorfismo permite que quem chama use uma operação compartilhada em diferentes implementações.

A programação funcional constrói resultados combinando funções. Seu hábito central é produzir novos valores a partir de entradas e limitar a mutação compartilhada. Lisp introduziu ideias funcionais amplamente usadas por volta de 1958; Haskell, Erlang, Clojure, F# e OCaml desenvolvem essas ideias de maneiras diferentes.

Saiba o que torna uma função pura

Uma função pura fornece o mesmo resultado para os mesmos argumentos e não tem efeitos colaterais. def with_tax(price): return price * 1.2 ilustra a ideia: with_tax(50) resulta em 60,0. Uma função que também acrescenta algo a uma lista global ou imprime uma mensagem tem um efeito além de seu valor de retorno. Um resultado que depende da hora atual também depende de mais do que os argumentos.

Uma chamada pura pode ser substituída por seu valor de retorno sem alterar o comportamento do programa. Essa propriedade é a transparência referencial. Ela torna simples os testes isolados e permite que chamadas independentes sejam executadas em paralelo sem disputar a atualização de um estado compartilhado.

A imutabilidade mantém um valor existente inalterado. [n + 1 for n in nums] cria uma nova lista, deixando nums intacta. Um programa ainda pode representar informações que mudam produzindo novas versões; ele não precisa sobrescrever a versão antiga.

Passe comportamento como dados

Funções são de primeira classe quando podem ser atribuídas a nomes, passadas como argumentos e retornadas como valores. Uma função de ordem superior recebe uma função ou retorna uma. Uma expressão lambda é uma expressão de função sem nome, como lambda n: n * n.

Três operações comuns de ordem superior formam uma sequência:

• filter mantém elementos que satisfazem um teste.
• map transforma cada elemento restante.
• reduce combina elementos em um resultado usando um acumulador.

Para somar os quadrados dos números pares de 1 até 6, a filtragem deixa 2, 4 e 6; elevar ao quadrado produz 4, 16 e 36; somar produz 56.

sum(map(lambda n: n * n,
        filter(lambda n: n % 2 == 0, range(1, 7))))

Aqui % 2 == 0 testa se um número é par, e range(1, 7) fornece os números de 1 até 6. Haskell expressa o mesmo cálculo como sum (map (^2) (filter even [1..6])).

Com reduce importado de functools do Python, reduce(lambda acc, n: acc + n, [3, 8, 5], 0) combina 0 com 3 para obter 3, depois com 8 para obter 11 e depois com 5 para obter 16. A sequência descreve transformações sem um laço externo que atualize um total compartilhado.

Preserve um ambiente ou chame um problema menor

def multiplier(k): return lambda x: k * x retorna uma função que mantém acesso a k. Assim, multiplier(3)(10) retorna 30 mesmo depois que a chamada externa terminou. A função retornada e o ambiente preservado formam um fechamento.

Na recursão, uma função chama a si mesma para um problema menor. O fatorial retorna 1 em n == 0; nos demais casos, retorna n * factorial(n - 1). Para 5, os produtos resultam em 120. Um cálculo finito precisa de um caso base alcançável. As chamadas aninhadas não resolvidas do Python acabam gerando RecursionError; linguagens com suporte adequado a chamadas de cauda podem reutilizar espaço na pilha para chamadas na posição final.

Usar funções por si só não torna o código funcional: funções procedurais podem alterar o estado. Programas funcionais reais ainda leem entradas e escrevem saídas, geralmente mantendo efeitos próximos às extremidades do programa e os cálculos centrais puros.

A programação declarativa descreve o resultado desejado e deixa os passos de execução a cargo de um mecanismo da linguagem. O código funcional geralmente é agrupado nessa ideia ampla, junto com linguagens de consulta e programação lógica.

Leia uma consulta como uma solicitação

Um banco de dados relacional armazena dados em tabelas. Suponha que students tenha as linhas de nome e nota Ana 92, Ben 75, Chen 80 e Dara 64:

SELECT name
FROM students
WHERE grade >= 80
ORDER BY name;

FROM indica a tabela, WHERE fornece a condição, SELECT escolhe o campo retornado e ORDER BY solicita ordem alfabética. Ana e Chen satisfazem a condição, incluindo a nota de Chen, exatamente 80. O resultado são seus nomes nessa ordem.

Um programa imperativo criaria uma lista de resultados, percorreria as linhas, testaria cada nota, acrescentaria os nomes que atendem à condição e ordenaria a lista. SQL fornece ao banco de dados o resultado exigido sem escrever esse laço.

Um otimizador de consultas escolhe um plano de execução. Ele pode varrer a tabela ou usar um índice disponível, uma estrutura de busca que pode acelerar pesquisas adequadas. Muitos índices usam estruturas ordenadas; outros usam organizações diferentes. Acrescentar um índice pode alterar o plano sem alterar a consulta. Mais dados ainda significam trabalho: declarar o resultado não garante que toda consulta exija poucos recursos.

Pergunte o que decorre de fatos e regras

A programação lógica descreve fatos e relações e depois procura valores que satisfaçam uma pergunta. Em Prolog:

parent(tom, bob).
parent(bob, ann).
grandparent(X, Z) :- parent(X, Y), parent(Y, Z).

A regra significa que X é avô ou avó de Z quando há um Y para o qual ambas as relações de pai ou mãe são verdadeiras. A consulta ?- grandparent(tom, Who). encontra Who = ann: Tom é pai de Bob e Bob é pai de Ann. Nomes iniciados por maiúsculas representam variáveis; os nomes em minúsculas identificam pessoas específicas.

Reconheça ferramentas declarativas ao seu redor

Uma fórmula de planilha =SUM(B2:B5) declara uma dependência. A planilha a recalcula quando células relevantes mudam. A expressão regular [0-9]{3}-[0-9]{4} descreve três algarismos, um hífen e quatro algarismos, como em “555-0199”. Um mecanismo de correspondência de texto realiza a busca.

CSS declara a aparência com uma regra como h1 { color: navy; }; HTML marca a estrutura da página. São notações declarativas, normalmente classificadas como linguagens de estilo e de marcação. Sua função difere da de uma linguagem de propósito geral que pode expressar uma ampla variedade de computações.

O código declarativo pode permanecer próximo da descrição de um problema e permitir que um mecanismo melhore seu método. Ele também dá a quem programa menos controle direto sobre passos individuais, o que pode tornar mais difícil diagnosticar um plano lento. Instruções concretas ainda são executadas por trás: declarativo descreve a forma como a pessoa expressa a tarefa, não um processador que funciona sem passos.

Um paradigma altera a forma como uma solução é expressa, não a resposta numérica que uma solução correta deve produzir. Considere pedidos com valores [120, 45, 300, 80]: encontre o total dos valores estritamente maiores que 100.

Acompanhe as mudanças de estado

A versão imperativa expõe o laço e o acumulador:

total = 0
for amount in amounts:
    if amount > 100:
        total = total + amount

O primeiro valor altera total para 120. O segundo o deixa inalterado. O terceiro o altera para 420, e o quarto o mantém nesse valor. O programa torna visível a ordem dos testes e das atualizações.

Transforme uma coleção

Uma expressão Python compacta no estilo funcional é sum(a for a in amounts if a > 100). Ela seleciona 120 e 300 e os combina em 420. Outra versão é sum(filter(lambda a: a > 100, amounts)). Aqui o predicado descreve quais valores pertencem ao conjunto selecionado, e sum os combina.

Uma expressão geradora ou uma chamada filter usa recursos multiparadigma do Python; sua presença não torna puras todas as partes da aplicação ao redor.

Coloque regras junto dos objetos

Em um projeto orientado a objetos, um Order armazena um amount e oferece is_large(), que retorna self.amount > 100. Um OrderBook contém objetos de pedidos e oferece large_total(). Esse método pode percorrer os pedidos em um laço, perguntar a cada um se atende à condição e somar os valores correspondentes.

O total continua sendo 420. A diferença está em onde ficam as responsabilidades: a regra para um pedido grande pertence a Order, e o trabalho no nível da coleção pertence a OrderBook. Outras funcionalidades podem reutilizar a regra sem copiar seu teste de limite.

Consulte o banco de dados

Se os dados já estiverem em um banco de dados relacional, SQL pode solicitar o total:

SELECT SUM(amount)
FROM orders
WHERE amount > 100;

O banco de dados escolhe o plano de busca e agregação. A consulta não instrui quem a chama a percorrer todas as linhas ou manter um acumulador local.

Combine estilos onde eles ajudam

Python oferece suporte a técnicas procedurais, orientadas a objetos e funcionais. JavaScript fornece objetos, funções de primeira classe e fechamentos. C++, C#, Kotlin, Scala, Swift e Rust também combinam estilos. Java é fortemente associada à programação orientada a objetos, mas oferece suporte a expressões lambda desde Java 8, em 2014; Haskell é puramente funcional.

Uma aplicação web pode usar classes para usuários e pedidos, transformações funcionais para dados de relatórios, atualizações imperativas dentro de métodos e SQL para consultas ao banco de dados. Essas escolhas funcionam em camadas diferentes.

A programação orientada a eventos acrescenta outra ideia de organização: registrar um tratador que é executado quando um evento chega. Em JavaScript, button.addEventListener("click", showMenu) passa showMenu como um valor de função. Um clique posterior o invoca. O próprio tratador pode usar objetos, transformações puras ou passos imperativos. Sua função orientada a eventos indica quando ele é executado, não o único estilo que seu corpo pode usar.

Nenhuma linguagem de programação é a mais adequada para todo projeto. Linguagens de propósito geral geralmente são Turing completas: com tempo e memória ilimitados, podem expressar a mesma classe de computações. As escolhas reais dependem de a solução ser adequada à plataforma, aos recursos, às ferramentas e às pessoas envolvidas.

Comece pelo que precisa funcionar

A plataforma costuma ser uma restrição rígida. Navegadores executam JavaScript e podem executar módulos compilados por meio do WebAssembly. TypeScript acrescenta verificação estática e compila para JavaScript. Swift é uma escolha padrão para aplicativos das plataformas Apple; Kotlin é recomendada para Android. SQL é a linguagem usual para consultas relacionais.

Em seguida, considere o domínio e o ecossistema. Python tem bibliotecas de dados e aprendizado de máquina amplamente usadas, como NumPy e pandas. R se concentra em estatística. C e C++ são comuns em sistemas operacionais, motores de jogos e código embarcado. Java e C# são comuns em grandes sistemas empresariais; Bash é útil para automatizar tarefas do sistema operacional.

Essas são associações práticas, não territórios exclusivos. Uma biblioteca adequada pode economizar muito mais trabalho de desenvolvimento do que uma pequena diferença na sintaxe da linguagem.

Examine as necessidades de recursos e segurança

Um microcontrolador com apenas alguns kilobytes de RAM pode precisar de controle detalhado sobre a memória e a sobrecarga de execução. C, C++ ou Rust podem ser adequadas quando o alvo oferece suporte a elas. Componentes exigentes de jogos ou bancos de dados também costumam favorecer essas linguagens, mas motores e limites de recursos variam: Unity usa C#, e alguns bancos de dados usam Java ou Go.

Antes de escolher pela velocidade, encontre o gargalo: a parte que limita o desempenho. Um programa que espera principalmente por uma resposta da rede não ficará muito mais rápido apenas porque um pequeno laço local é compilado com mais eficiência. Meça uma carga de trabalho representativa na plataforma-alvo.

A segurança de memória reduz erros como acesso inválido à memória. Rust seguro verifica regras de propriedade em tempo de compilação; linguagens gerenciadas como Java, C#, Go e Python oferecem gerenciamento de memória em tempo de execução. A tipagem estática detecta muitas operações incompatíveis antes da execução, o que pode ajudar em uma base de código grande. Nem a segurança de memória nem a tipagem estática provam que a lógica do programa está correta.

Inclua o custo de manter o resultado

O conhecimento da equipe, os desenvolvedores disponíveis, depuradores, ferramentas de teste, bibliotecas, licenças e código existente afetam a decisão. Uma linguagem conhecida e com suporte pode reduzir os custos de entrega e manutenção. Reescrever um sistema que funciona cria trabalho de migração e riscos, mesmo que a nova linguagem tenha recursos atraentes.

Em uma rede meteorológica de uma cidade, componentes diferentes têm necessidades diferentes:

Uma justificativa útil relaciona cada escolha a um requisito: “A equipe já mantém o serviço Java, e suas bibliotecas oferecem suporte à nova funcionalidade”. Uma posição em um ranking de popularidade, sozinha, não fornece esse raciocínio. Pesquisas podem indicar uma comunidade grande ou um grupo amplo de profissionais disponíveis para contratação; elas não estabelecem a melhor linguagem para uma carga de trabalho específica.