Tecnologia e sociedade

Quando se fala em tecnologia, muitos pensam primeiro em telas brilhando, aplicativo novo, celular que acabou de ser lançado. Só que por trás de tudo isso tem uma ideia bem mais profunda e, de certa forma, desconfortável: toda tecnologia é uma extensão para o ser humano. Não é só um acessório bonitinho, é um pedaço do nosso jeito de pensar que foi colocado para fora do corpo, transformado em ferramenta. A partir do momento em que isso acontece, o próprio cérebro começa a mudar, começa a se reorganizar em torno dessas extensões. Pensar deixa de ser uma coisa puramente biológica e passa a ser também uma atividade tecnológica.

Dá para enxergar isso começando pela escrita. Antes de existir letra em pedra, papiro, papel ou tela, tudo o que uma pessoa sabia precisava caber dentro da própria cabeça, ou circular em histórias contadas em voz alta. Se alguém esquecia um detalhe importante, aquela parte da memória simplesmente se perdia. A escrita mudou o jogo porque pegou uma função fundamental da mente, lembrar, e empurrou para fora, para o mundo físico. Um caderno, um diário, um bloco de notas no celular são exemplos muito simples disso. Quando você anota um número de telefone ou uma ideia solta, não está só registrando, está tirando um peso da memória. A mente deixa de gastar energia lembrando detalhes e passa a usar essa energia para outras coisas, como criar, planejar, conectar pontos. A escrita virou uma espécie de HD externo da consciência.

Quando os livros começaram a ser copiados em massa com a imprensa, outra parte da mente foi estendida. Falar sempre foi a forma mais direta de compartilhar pensamentos, mas a fala ao vivo é limitada no espaço e no tempo. A imprensa pegou essa fala e espalhou pelo mundo. Um panfleto, um jornal, um livro carregam a voz de alguém para pessoas que nem tinham nascido quando aquele texto foi escrito. A fala deixou de depender do corpo presente. Isso muda totalmente a escala do que chamamos de conversa social. Ideias religiosas, científicas, políticas e filosóficas passaram a viajar muito rápido, influenciar muitos ao mesmo tempo, criar movimentos e revoluções. A imprensa não é só uma máquina de imprimir tinta, é uma extensão da nossa capacidade de falar e de convencer.

Durante tempos, essa extensão da mente ainda eram estáticas. Um livro não responde, não calcula, não simula nada. O computador trouxe outra dimensão para essa história. Quando alguém abre uma planilha e testa cenários, ou quando usa um simulador para ver o que acontece se mudar determinado parâmetro, está terceirizando parte do raciocínio para uma máquina. Isso não significa que a pessoa fica mais burra, significa que o tipo de inteligência que importa começa a mudar. Em vez de decorar fórmulas, importa mais saber formular perguntas, organizar dados, imaginar hipóteses. O computador virou uma extensão do raciocínio porque ajuda a percorrer caminhos lógicos em alta velocidade, repetindo, corrigindo, ajustando, sem cansar. Uma simulação de clima, um algoritmo de recomendação, um jogo de estratégia, tudo isso são espaços onde mente humana e processamento de máquina se misturam.

A programação entra como um passo a mais nessa extensão, quando alguém aprende a programar, aprende a transformar lógica em instruções explícitas. Aquela estrutura mental que já existia, do tipo “se isso acontecer, faço aquilo, senão vou por este outro caminho”, vira código. Programar é treinar o cérebro para pensar de maneira estruturada, desmontando problemas grandes em partes menores, criando funções que se repetem, prevendo exceções, desenhando fluxos. Para a máquina, aquilo é só uma sequência de bits, mas para quem escreve, é um espelho do próprio raciocínio. A sensação de ver um programa funcionando, mesmo que seja simples, é a de ver um pedaço do seu jeito de pensar ganhando vida fora da cabeça. O código acaba se tornando uma segunda linguagem do cérebro, tão natural que, com o tempo, a pessoa passa a pensar em termos de funções, loops e condições até em situações do dia a dia.

Quando se fala de sistemas operacionais, essa ideia de extensão da mente ganha um componente político, técnico e até filosófico. O Linux é um exemplo muito forte disso. Ele não é só um sistema para rodar programas, é um ambiente que convida a pessoa a entender o que está acontecendo por baixo da interface. Com Linux, é possível fuçar no núcleo do sistema, automatizar tudo com scripts, trocar o gerenciador de janelas, escolher como o sistema inicializa, montar o próprio fluxo de trabalho. Isso amplia a autonomia técnica. Em vez de aceitar passivamente o computador de como ele funciona seguindo como o fabricante decidiu, o usuário aprende a tomar decisões, ajustar, experimentar. Essa autonomia não é só técnica, é mental. Dá a sensação de que o computador é um instrumento de criação, não apenas um produto de consumo. A mente passa a se ver como autora do próprio ambiente digital.

Com o tempo, essas extensões foram se acumulando e se interligando até chegar em um ponto curioso: já não pensamos mais sem máquinas, pensamos com máquinas. Um exemplo simples é o hábito de procurar qualquer coisa no buscador antes mesmo de refletir alguns minutos sobre o assunto. A primeira reação a uma dúvida não é olhar para dentro, é alcançar o celular. A mente passa a rodar junto com o navegador, com o histórico, com as abas abertas. O mesmo vale para GPS, que redesenhou a forma como lidamos com espaço. Antigamente era comum memorizar caminhos, decorar pontos de referência, construir um mapa mental da cidade. Hoje, o cérebro terceirizou boa parte desse trabalho para o aplicativo de mapa. Em troca, ganhou liberdade para se ocupar com outras tarefas durante o trajeto, como ouvir um podcast ou planejar o dia. A pergunta é até que ponto isso é ganho e até que ponto é dependência.

Outro exemplo de como o pensamento se mistura com a máquina é o texto preditivo. Quando alguém digita uma frase e o teclado sugere a continuação, não está só acelerando o processo de escrever, está influenciando o conteúdo do pensamento. Certas expressões aparecem com mais frequência, certas formas de falar são reforçadas, alguns caminhos de frase se tornam mais naturais porque a sugestão já veio pronta. Isso cria um ciclo curioso, em que a mente alimenta o algoritmo com dados, o algoritmo devolve padrões, e a mente começa a pensar dentro desses padrões. A tecnologia deixa de ser apenas uma ferramenta e passa a ser um ambiente cognitivo, um lugar onde o pensamento acontece.

Existe também um lado emocional nessa história, redes sociais são extensão da nossa necessidade de reconhecimento, pertencimento e conversa. Elas registram memórias, lembram aniversários, sugerem recordações, mostram o que os outros estão pensando. O feed se torna uma espécie de espelho coletivo, onde cada um vê fragmentos de vidas e opiniões. Isso muda como construímos nossa identidade. Em vez de lembrar da própria história só pela memória interna, surgem lembranças em foto, em vídeo, em post antigo. A mente passa a depender dessa camada digital para organizar o passado, construir narrativas, revisar escolhas. A extensão da mente não é só racional, é também afetiva.

A grande virada dos últimos anos é que, antes, o ser humano adaptava suas ferramentas ao próprio ritmo. Levava tempo para aprender um ofício, fazer uma mudança, adotar um novo instrumento. Hoje, o cenário parece invertido. e a sensação é de estar correndo para acompanhar o ritmo das ferramentas. Sistemas operacionais mudam de versão o tempo todo, aplicativos atualizam a interface sem pedir licença, novas linguagens, frameworks e plataformas surgem em sequência. Quem trabalha com tecnologia sente essa pressão diretamente, mas qualquer pessoa com smartphone percebe que precisa reaprender pequenos detalhes com frequência. Isso tem impacto na mente, que passa a operar num estado constante de atualização.

Quando o cérebro precisa se adaptar o tempo todo, cresce a sensação de cansaço e dispersão. A atenção é cortada por notificações, por janelas que se abrem, por mensagens urgentes que exigem resposta imediata. A mente deixa de sustentar longos períodos de foco contínuo e passa a funcionar em fragmentos. Em termos cognitivos, isso é rearranjo de prioridades. Tarefas profundas exigem esforço, então ficam para depois. Tarefas superficiais, como responder mensagens e conferir alertas, dão pequenas recompensas rápidas e tomam o lugar central. A tecnologia, que poderia ser uma extensão poderosa para foco e clareza, acaba empurrando para um modo de operação acelerado, reativo e ansioso, se usada sem cuidado.

O ponto é que essa adaptação ao ritmo das ferramentas não é inevitavelmente negativa. Pode ser uma escolha consciente. Quando alguém organiza o próprio ambiente digital de forma cuidadosa, ajustando notificações, escolhendo bem quais aplicativos realmente merecem espaço, criando rotinas para estudo e trabalho, está usando a tecnologia como extensão da mente de um jeito mais saudável. Um simples editor de texto configurado com um tema agradável, atalhos bem pensados e uma estrutura de pastas clara pode se transformar em um laboratório de ideias. Um sistema de notas bem organizado, seja ele simples ou sofisticado, vira um mapa externo do pensamento que ajuda a não se perder em meio ao excesso de informação.

Nesse cenário, aprender o básico de programação pode ser visto menos como uma habilidade técnica isolada e mais como uma forma de alfabetização mental. Quando alguém cria um script para automatizar uma tarefa chata, está dizendo para o próprio cérebro que nem tudo precisa ser repetido manualmente. Isso liberta tempo e energia. Mesmo quem não pretende trabalhar como desenvolvedor pode se beneficiar dessa forma de pensar em termos de regras claras, entradas e saídas, dependências, exceções. Essa lógica estruturada conversa bem com o mundo real, em que problemas complexos raramente se resolvem de uma vez só, mas sim em partes, em etapas encadeadas.

Pensar a tecnologia como extensão da mente também ajuda a fazer escolhas mais conscientes. Se cada ferramenta expande uma parte da nossa capacidade mental, é importante perguntar que tipo de mente se deseja construir. Uma rotina baseada só em redes sociais rápidas tende a fortalecer a impaciência e a busca por estímulos constantes. Um uso mais focado em leitura profunda, escrita longa, experimentação criativa em código ou arte digital fortalece outras qualidades, como concentração, senso de detalhe, pensamento crítico. Não existe neutralidade completa, porque toda ferramenta puxa o pensamento em alguma direção. Ao mesmo tempo, não existe necessidade de demonizar essa dependência, já que humanos sempre dependeram de ferramentas, desde a primeira pedra lascada.

O código se consolidou como uma segunda linguagem do cérebro porque traduz uma característica muito antiga da mente humana, o desejo de antecipar resultados e controlar processos. Quando alguém escreve um programa, está criando um pequeno mundo com regras próprias, onde sabe de antemão o que deve acontecer se tudo estiver certo. Isso dialoga com a necessidade de previsibilidade em um mundo que, fora da tela, é cheio de imprevistos. Essa sensação de domínio pode ser viciante, mas também pode ser canalizada para resolver problemas reais, automatizar trabalhos repetitivos, criar ferramentas para outras pessoas, espalhar conhecimento.

Leia Mais

Uso de movimento estruturado para aumento de resolução

 

Quando a câmera se mexe durante a captura, o resultado costuma ser uma imagem tremida e sem foco. Mas um grupo de pesquisadores descobriu que esse “erro” pode, na verdade, esconder uma vantagem surpreendente. Usando um novo algoritmo de reconstrução, eles conseguiram transformar fotos borradas em imagens de altíssima resolução, chegando perto da qualidade de gigapixel, tudo isso com câmeras comuns.

A ideia surgiu da curiosidade em entender os limites da fotografia computacional. Se o movimento cria borrões, esses borrões também carregam informações. A lógica é simples, cada ponto de luz deixa um rastro conforme a câmera se move. O algoritmo usa esses rastros para descobrir onde estavam os detalhes finos da cena original e reconstruí-los com precisão em uma grade muito mais densa, quase abaixo do nível de um pixel.

Normalmente, para transformar uma imagem de baixa resolução em uma mais detalhada, os métodos tentam relacionar a versão simples com uma versão “ideal” por meio de modelos matemáticos. O problema é que o ganho costuma ser pequeno e limitado, se a imagem inicial está borrada, o máximo de nitidez possível também fica travado.

Sendo este novo método vira essa lógica de cabeça para baixo. Em vez de lutar contra o movimento, ele o usa a favor. As faixas deixadas pelos pontos de luz ajudam a decodificar informações escondidas, revelando detalhes que a câmera sozinha não conseguiria capturar parada.

Nos testes, os pesquisadores usaram câmeras comuns em diferentes situações. Em alguns casos, registraram várias imagens de uma mesma cena, movendo o sensor em pequenas variações. Em outros, capturaram apenas uma imagem enquanto o sensor vibrava ou se deslocava em linha reta. Depois, aplicaram o algoritmo para combinar tudo em uma única imagem de alta resolução.

Os resultados mostraram que o movimento, quando bem interpretado, traz mais dados sobre a cena do que se imaginava. A técnica pode ser aplicada desde microscopia até imagens de satélite, onde é preciso capturar áreas amplas com detalhes finos. E também há potencial em fotografia de arquivo, arte e patrimônio histórico, onde cada detalhe importa.

A principal vantagem dessa abordagem é permitir alta resolução sem precisar de sensores gigantescos ou equipamentos caros. Para áreas como biologia, conservação e monitoramento ambiental, isso pode representar um salto enorme. Em vez de depender de lentes e sensores ultra caros, basta uma boa câmera e o algoritmo certo. Os pesquisadores acreditam que o método pode ser usado em câmeras de consumo, inclusive em celulares, e também em sistemas científicos com sensores de alta precisão. Eles já planejam demonstrar o método em diferentes dispositivos, de câmeras simples a sensores térmicos e CCDs laboratoriais.

A tecnologia atual tenta eliminar o borrão, mas ninguém tinha pensado em usá-lo como fonte de informação. O estudo mostra que dá para fazer o oposto, transformar o movimento em detalhe. É uma daquelas ideias que parecem contraintuitivas  e justamente por isso abrem caminho para algo novo. Com esse tipo de técnica, o futuro da fotografia computacional pode ser bem diferente do que se imagina, onde o tremor da mão não estraga a foto, mas a deixa ainda mais rica em detalhes.

Referência:
 

Nós consideramos os limites da super-resolução usando restrições de imagem. Devido a várias limitações teóricas e práticas, os métodos baseados em reconstrução têm sido amplamente restritos a pequenos aumentos de resolução. Além disso, o desfoque de movimento é geralmente visto como um incômodo que impede a super-resolução. Mostramos que, ao usar informações de movimento de alta precisão, priors de imagem esparsos e otimização convexa, é possível aumentar a resolução por grandes fatores. Uma operação fundamental na super-resolução é a deconvolução com uma caixa. Em geral, a convolução com uma caixa não é inversível. No entanto, obtemos reconstruções perfeitas de sinais esparsos usando otimização convexa. Também mostramos que o desfoque de movimento pode ser útil para a super-resolução. https://arxiv.org/abs/2505.15961

Leia Mais

Como escrever funções em Python eficiente

Você criou sua primeira função em Python. Ela roda, não dá erro, devolve o resultado certo… missão cumprida.

Duas semanas depois, você abre o arquivo de novo e pensa:

“Quem foi que escreveu isso? O que essa função faz mesmo?”

Esse é um problema muito comum, tanto para quem está começando quanto para profissionais experientes.

Escrever funções legíveis não tem nada a ver com ser “gênio” ou “programador avançado”. Tem a ver com outra coisa bem mais simples: comunicar bem. Ou seja:

• deixar claro o que a função faz;
• deixar claro o que ela espera receber;
• deixar claro o que ela devolve;
• facilitar a vida da próxima pessoa que vai ler o código (que muitas vezes é você mesmo no mês seguinte).

A ideia deste texto é justamente essa: mostrar como escrever funções que parecem um bom texto de jornal, e não um enigma que ninguém consegue decifrar.

Dê nomes às funções como se estivesse explicando a um amigo

Pense no nome de uma função como o título de uma matéria: antes de ler o conteúdo, você já quer ter uma boa ideia do assunto.

Em programação, é a mesma lógica: o nome da função deve dizer, sozinho, o que ela faz.

Exemplo ruim

def proc(dados):
    return sum(dados) / len(dados)

“proc”, “dados”… Nada disso diz muita coisa. Para entender, você é obrigado a olhar o corpo da função e “traduzir” mentalmente.

Exemplo bom

def calcular_media(numeros):
    return sum(numeros) / len(numeros)

Aqui, o nome calcular_media já fala tudo:

• começa com um verbo (calcular), indicando que a função faz uma ação;
• termina com o que está sendo calculado (media).

O parâmetro numeros diz que a função espera uma coleção de números (por exemplo, uma lista).

Você não precisa ler o código para intuir o que acontece:

• sum(numeros) → soma os valores;
• len(numeros) → conta quantos valores existem;
• a divisão faz a média.

É como olhar para o título de uma reportagem e já ter uma boa noção do conteúdo antes de ler o texto completo.

💡 Pense assim:
Se o nome da função fosse a frase que você usaria para explicar o que ela faz para um colega no café, qual seria?

Use nomes descritivos também para os parâmetros

Parâmetros são as entradas da função — aquilo que você entrega para ela trabalhar. Se os nomes forem confusos, o uso da função fica nebuloso.

É como um formulário mal preenchido: se o campo está escrito “X” e você não sabe se é CPF, RG ou telefone, a chance de erro é grande.

Exemplo ruim

def desconto(p, r):
    return p * (1 - r)

O que é p? Preço? Produto?
E r? Taxa? Desconto? Juros?

Exemplo bom

def aplicar_desconto(preco_original, taxa_desconto):
    return preco_original * (1 - taxa_desconto)

Agora ficou claro:

• preco_original → o preço original;
• taxa_desconto → a taxa de desconto (por exemplo, 0.2 para 20%).

Quando alguém lê:

aplicar_desconto(100, 0.2)

já entende que está aplicando 20% de desconto em 100. O código se explica sozinho, sem comentário.

É como numa página de compra online: em vez de um campo chamado “valor X”, você vê “Preço do produto (em reais)”. Fica impossível confundir.

Mantenha as funções curtas e com uma única responsabilidade

Uma função deveria fazer uma coisa bem feita.

Quando ela faz duas, três, quatro coisas diferentes, vira um “trabalho interno” difícil de testar, de reaproveitar e de entender.

Pense numa pessoa no trabalho que precisa:

• atender cliente;
• fazer planilha;
• emitir nota fiscal;
• arrumar o estoque;
• responder e-mail.

Tudo isso ao mesmo tempo. Fica confuso e ineficiente.

Exemplo ruim: função faz tudo

def processar_pedido(itens, email_cliente, codigo_desconto):
    # Calcular subtotal
    subtotal = sum(item["preco"] * item["quantidade"] for item in itens)

    # Aplicar desconto
    if codigo_desconto  "SAVE10":
        desconto = 0.10
    elif codigo_desconto  "SAVE20":
        desconto = 0.20
    else:
        desconto = 0
    total = subtotal * (1 - desconto)

    # Enviar e-mail
    assunto = "Confirmação de Pedido"
    corpo = f"Seu pedido totalizou R$ {total:.2f}"
    enviar_email(email_cliente, assunto, corpo)

    return total

Essa função:

1. calcula o subtotal,
2. decide o desconto,
3. aplica o desconto,
4. prepara o e-mail,
5. envia o e-mail,
6. devolve o total.

Ela é o equivalente digital de um funcionário sobrecarregado.

Exemplo bom: dividir o problema em etapas

def calcular_subtotal_pedido(itens):
    return sum(item["preco"] * item["quantidade"] for item in itens)


def obter_taxa_desconto(codigo_desconto):
    taxas_desconto = {"SAVE10": 0.10, "SAVE20": 0.20}
    return taxas_desconto.get(codigo_desconto, 0)


def aplicar_desconto_ao_subtotal(subtotal, taxa_desconto):
    return subtotal * (1 - taxa_desconto)


def enviar_email_confirmacao_pedido(email_cliente, total):
    assunto = "Confirmação de Pedido"
    corpo = f"Seu pedido totalizou R$ {total:.2f}"
    enviar_email(email_cliente, assunto, corpo)


def processar_pedido(itens, email_cliente, codigo_desconto):
    subtotal = calcular_subtotal_pedido(itens)
    taxa_desconto = obter_taxa_desconto(codigo_desconto)
    total = aplicar_desconto_ao_subtotal(subtotal, taxa_desconto)
    enviar_email_confirmacao_pedido(email_cliente, total)
    return total

Agora cada função tem um papel claro:

• calcular_subtotal_pedido → calcula o subtotal;
• obter_taxa_desconto → entende o código de desconto;
• aplicar_desconto_ao_subtotal → aplica o desconto;
• enviar_email_confirmacao_pedido → envia o e-mail;
• processar_pedido → orquestra tudo.

A função principal lê como uma receita:

1. calcule o subtotal,
2. descubra a taxa de desconto,
3. aplique o desconto,
4. envie o e-mail,
5. devolva o total.

Isso é muito mais fácil de testar (você testa cada pedacinho separadamente) e de manter.

Explique o propósito com docstrings

Mesmo com bons nomes, algumas funções precisam de um pouco mais de contexto. É aí que entram as docstrings, aquelas “mini-documentações” logo abaixo da definição da função.

Elas servem para explicar:

• por que a função existe;
• o que cada parâmetro significa;
• o que a função devolve;
• exemplos de uso.

É como o manual de um eletrodoméstico: o aparelho você até usa sem ler tudo, mas a explicação facilita muito.

Exemplo

def calcular_custo_envio(peso_kg, distancia_km, entrega_expressa=False):
    """
    Calcula o custo de envio com base no peso do pacote e na distância.

    Args:
        peso_kg (float): Peso do pacote em quilogramas.
        distancia_km (float): Distância do envio em quilômetros.
        entrega_expressa (bool): Se True, usa envio expresso (padrão: False).

    Returns:
        float: Custo total de envio em reais.

    Exemplo:
        >>> calcular_custo_envio(5.0, 100, entrega_expressa=True)
        45.50
    """
    taxa_base = 2.50
    taxa_por_kg = 1.20
    taxa_por_km = 0.15
    multiplicador_expressa = 2.0 if entrega_expressa else 1.0

    custo = (
        taxa_base + (peso_kg * taxa_por_kg) + (distancia_km * taxa_por_km)
    ) * multiplicador_expressa
    return round(custo, 2)

Repare que, sem ver o corpo da função, você já sabe:

• que ela calcula custo de frete;
• o que são peso_kg, distancia_km e entrega_expressa;
• o que é devolvido (um número decimal com o custo);
• um exemplo concreto de uso.

Em muitos editores de código, essa docstring aparece quando você passa o mouse em cima da função ou quando digita o nome dela. É documentação que anda junto com o código, sem precisar abrir arquivos à parte.

Use nomes claros também dentro da função

Não adianta ter nomes bons para a função e para os parâmetros se, lá dentro, você usa variáveis chamadas tmp, x, y, res. Isso obriga quem lê a “traduzir” tudo de novo.

É como pegar uma planilha em que as colunas se chamam “A”, “B”, “C”, sem dizer se é “Data”, “Cliente”, “Valor”.

Exemplo ruim

def calc_imc(p, a):
    a_m = a / 100
    res = p / (a_m**2)
    return round(res, 1)

Você até consegue entender, mas precisa pensar: p é peso, a é altura, res é o quê?

Exemplo bom

def calcular_imc(peso_kg, altura_cm):
    altura_metros = altura_cm / 100
    imc = peso_kg / (altura_metros**2)
    return round(imc, 1)

Aqui, tudo é autoexplicativo:

• peso_kg → peso em quilos;
• altura_cm → altura em centímetros;
• altura_metros → altura convertida para metros;
• imc → índice de massa corporal.

Quem lê não precisa ficar “adivinhando” o que cada coisa significa. Isso reduz erros e torna o código muito mais amigável, inclusive para quem está aprendendo.

Evite “números mágicos”: prefira constantes com nome

“Número mágico” é qualquer número que aparece no código sem explicação, como 7, 14, 5….

Quem lê fica se perguntando: “Por que 7? Por que não 6 ou 8?”.
São regras escondidas que só existem na cabeça de quem escreveu.

O ideal é transformar esses números em constantes com nome, para deixar claro o significado.

Exemplo ruim

def calcular_multa_atraso(dias_atrasado):
    if dias_atrasado <= 7:
        return dias_atrasado * 2
    else:
        return 14 + (dias_atrasado - 7) * 5

De onde vieram 7, 2, 14, 5? É multa de biblioteca? De estacionamento? Qual a regra?

Exemplo bom

def calcular_multa_atraso(dias_atrasado):
    TAXA_DIARIA_PRIMEIRA_SEMANA = 2
    PERIODO_CARENCIA_DIAS = 7
    MULTA_BASE_APOS_CARENCIA = 14
    TAXA_DIARIA_APOS_CARENCIA = 5

    if dias_atrasado <= PERIODO_CARENCIA_DIAS:
        return dias_atrasado * TAXA_DIARIA_PRIMEIRA_SEMANA
    else:
        dias_apos_carencia = dias_atrasado - PERIODO_CARENCIA_DIAS
        return MULTA_BASE_APOS_CARENCIA + (dias_apos_carencia * TAXA_DIARIA_APOS_CARENCIA)

Agora a regra fica explícita:

• existe um período de carência (PERIODO_CARENCIA_DIAS = 7 dias);
• nesse período, a multa é de 2 por dia (TAXA_DIARIA_PRIMEIRA_SEMANA);
• depois disso, existe uma multa base (MULTA_BASE_APOS_CARENCIA = 14);
• e um valor diário maior (TAXA_DIARIA_APOS_CARENCIA = 5).

É como ler um contrato: os valores e condições estão claramente descritos, e não escondidos em anotações soltas.

Outra vantagem: se um dia o valor da taxa mudar, você altera um lugar só (a constante), em vez de caçar o número 5 ou 7 espalhado pelo código inteiro.

Use type hints para deixar tudo ainda mais claro

Type hints (anotações de tipo) são uma forma de dizer quais tipos de dados a função espera e qual tipo ela devolve.

Python é uma linguagem dinâmica (não obriga a declarar tipos), mas os type hints ajudam:

• a evitar erros de uso;
• a deixar o código mais claro;
• a permitir que ferramentas e IDEs detectem problemas antes de rodar.

É como um formulário bem preenchido:

• “Idade (em anos):” → você já sabe que ali deve ir um número inteiro;
• “Nome completo:” → sabe que é texto;
• “É assinante? (Sim/Não)” → uma escolha booleana.

Exemplo

def formatar_saudacao_usuario(nome_usuario: str, idade: int, eh_membro: bool = False) -> str:
    status_assinatura = "membro" if eh_membro else "convidado"
    return f"Olá {nome_usuario}, idade {idade}. Você é {status_assinatura}."

Aqui, os type hints dizem:

• nome_usuario: str → espera uma string como nome;
• idade: int → espera um número inteiro como idade;
• eh_membro: bool = False → espera um valor verdadeiro ou falso, com padrão False;
• -> str → a função devolve uma string.

Se você tentar passar, por exemplo, uma lista no lugar da idade, ferramentas de análise de código podem acusar o erro antes mesmo da execução.

Para projetos maiores, isso faz uma diferença enorme em qualidade e manutenção.

Conclusão

Escrever funções legíveis não é escrever o “código perfeito”.

É fazer escolhas que ajudam quem vem depois:

• nomes claros para funções, parâmetros e variáveis;
• funções curtas, cada uma com uma responsabilidade bem definida;
• docstrings que explicam o propósito e o uso;
• constantes no lugar de números soltos;
• type hints para deixar os tipos explícitos.

No fundo, é tratar seu código como um texto que será lido, relido e interpretado.

A melhor recompensa é ouvir alguém — ou você mesmo no futuro, abrir o arquivo, ver a função e dizer:

“Ah, entendi rapidinho o que isso faz.”

No próximo passo da sua jornada em Python, o mesmo raciocínio vale para classes e estruturas maiores: nomes bons, responsabilidades claras e código que conversa bem com quem lê.

Até lá, siga praticando: a cada função nova, pergunte-se:

“Se eu voltar aqui daqui a seis meses, vou entender isso sem sofrimento?”

Se a resposta for “sim”, você está no caminho certo.

Leia Mais

Como o Red Hat OpenShift ajuda no desenvolvimento da ciência moderna

Plataforma de software criada para empresas acaba ajudando a descobrir genes, prever o clima e treinar inteligências artificiais

A infraestrutura em um laboratório de pesquisas se torna muito importante para novas descobertas. Nunca sabemos quais software, hardware, infraestrutura por trás de uma pesquisa. Os milhares de terabytes de dados processados constantemente, rodando em continuamente o tempo todo e ajudando a calcular e visualizar experimentos para uma nova pesquisa. E isso economizando tempo para o pesquisador

Aqui vamos falar um pouco de como o OpenShift da Red Hat consegue dar soluções para a ciência moderna, facilitando muito pesquisas atuais.

O que é o OpenShift

Tecnicamente, o OpenShift é uma plataforma baseada em Kubernetes, o sistema mais usado hoje para orquestrar containers. Em português bem direto:

• Container é um “pacote” que leva junto o programa e tudo que ele precisa para rodar.

• Kubernetes é o “cérebro” que distribui esses containers por vários servidores.

• OpenShift é um “Kubernetes turbinado”, com segurança, painel gráfico, ferramentas de desenvolvimento e gestão prontas.

Para o cientista, isso se traduz em algo simples:

“Eu clico ou rodo um comando e o sistema cuida do resto: onde vai rodar, quanto recurso vai usar, como escalar, como manter tudo organizado.”

Por que laboratórios se interessaram por uma ferramenta corporativa?

O OpenShift nasceu para resolver problemas de empresas: muitos sistemas, muitos times, muita coisa rodando ao mesmo tempo. A ciência moderna vive um cenário muito parecido:

• volumes gigantescos de dados

• equipes multidisciplinares (biólogos, físicos, médicos, cientistas de dados)

• necessidade de repetir experimentos com precisão

• uso intenso de nuvem, servidores locais e, cada vez mais, GPUs

Alguns pontos explicam a adoção em pesquisa:

1. Reprodutibilidade
   O experimento vira um container. Esse “pacote” é imutável: mesma versão de Python, mesmas bibliotecas, mesmo sistema. Outro laboratório pode rodar o mesmo container e comparar resultados com muito mais confiança.

2. Escala
   Analisar o genoma de uma pessoa é uma tarefa pesada. De uma população inteira, então, nem se fala. Com OpenShift, é possível disparar dezenas ou centenas de análises em paralelo, cada uma em seu container.

3. Compartilhamento controlado
   Cada grupo ganha seu “projeto” dentro do cluster. Há isolamento, regras de acesso, quotas de recurso. Times distintos trabalham no mesmo ambiente físico sem bagunça.

4. Nuvem e datacenter jogando juntos
   OpenShift roda em servidores locais e em nuvens públicas. Um laboratório pode manter um cluster pequeno internamente e “esticar” para a nuvem em momentos de pico.

Genômica: o laboratório que virou fábrica de dados

Na bioinformática o cenário é claro: máquinas de sequenciamento geram arquivos gigantescos com informações de DNA e RNA. Nada disso é útil antes de passar por uma bateria de programas:

• limpeza de leituras

• alinhamento ao genoma de referência

• detecção de variantes

• análises estatísticas

Cada etapa costuma ser um software diferente, com dependências próprias e versões temperamentais. Em vez de instalar tudo manualmente em cada servidor, equipes empacotam o pipeline em containers.

No OpenShift, esse pipeline vira um fluxo de trabalho automatizado:
cada etapa aparece como um conjunto de containers, o cluster distribui o trabalho e, se for preciso analisar mais amostras, basta aumentar o número de réplicas. O pesquisador acompanha tudo num painel web, como se estivesse vendo uma linha de produção.

Hospitais que trabalham com diagnóstico por genômica usam isso para reduzir o tempo entre a coleta do material e um laudo que possa ajudar o médico na tomada de decisão.

Clima, meio ambiente e o aperto do prazo

Prever chuva, ondas de calor ou comportamento de um furacão exige modelos matemáticos sofisticados. Tradicionalmente, isso rodava em supercomputadores de uso difícil e interfaces pouco amigáveis.

Com containers e OpenShift, simulações climáticas podem ser empacotadas e distribuídas com mais flexibilidade:

• grupos testam cenários com parâmetros diferentes

• rodadas de simulação rodam em paralelo

• resultados são armazenados de forma organizada para análise posterior

Institutos ambientais conseguem, por exemplo, disparar dezenas de simulações de uma mesma região, mudando variáveis como desmatamento ou emissões de poluentes, e comparar cenários com agilidade.

Física, astronomia e o universo em pedacinhos

Colisores de partículas e grandes telescópios produzem dados em volume que não caberia nem em todos os HDs de um departamento de física. Esses dados precisam ser filtrados, reconstruídos, analisados, cruzados com simulações.

A lógica se repete: cada etapa vira um container, o OpenShift orquestra os recursos, pesquisadores usam notebooks Jupyter dentro do cluster para explorar resultados.

Um físico pode abrir o navegador, conectar-se ao ambiente de análise e ter acesso ao mesmo código e ferramentas em qualquer lugar do mundo, desde que tenha permissão. A infraestrutura complexa fica escondida atrás de uma interface web.

Inteligência artificial científica

Redes neurais passaram a participar do dia a dia de várias áreas:

• identificar tumores em exames de imagem

• classificar galáxias em grandes levantamentos astronômicos

• prever propriedades de moléculas na busca por novos fármacos

• analisar séries temporais climáticas

OpenShift entra aí como plataforma para:

• disponibilizar notebooks Jupyter para pesquisadores

• treinar modelos em GPUs do cluster

• versionar modelos e dados

• colocar modelos em produção, respondendo a outros sistemas

Um time pode, por exemplo, desenvolver um modelo de IA que detecta padrões suspeitos em tomografias. O treinamento ocorre em containers com GPU. Depois, o modelo já treinado vira outro container, exposto como serviço para um sistema hospitalar interno.

O dia de trabalho de um pesquisador num mundo com OpenShift

Em vez de “mandar e-mail para o pessoal da TI pedindo servidor”, o roteiro tende a ser outro:

1. O cientista acessa um portal interno baseado em OpenShift.

2. Cria um novo projeto ou entra no projeto do grupo.

3. Escolhe um ambiente pronto: Jupyter com Python, RStudio, ou um container específico do laboratório.

4. Sobe os dados ou aponta para o local onde eles estão no storage do cluster.

5. Executa o pipeline, script ou treinamento de modelo.

6. Acompanha uso de CPU, memória, GPU e tempo de execução pela interface.

7. Se precisar repetir daqui a seis meses, o ambiente estará idêntico, porque o container não mudou.

TI e ciência deixam de disputar o mesmo computador e passam a colaborar na mesma plataforma.

O que isso significa para quem está de fora

Para quem vê de fora, OpenShift é só mais um nome no meio de tantos. Dentro de universidades, centros de pesquisa e hospitais, a história muda: é uma peça de infraestrutura que ajuda a transformar código em descoberta, ideia em experimento reprodutível, teste isolado em colaboração global.

Leia Mais

Linux, o essencial para um cientista de verdade

Na maioria das fotos de grandes laboratórios, raramente aparece, mas sempre está lá. Vemos telescópios apontados para o céu, braços robóticos milimétricos, cientistas em volta de gráficos coloridos. Mas, se a câmera desse um zoom nas telas desses computadores, em muitos casos o que surgiria seria algo bem familiar para quem gosta de tecnologia: um terminal preto, algumas janelas simples… e, nos bastidores, o Linux.

Ele é o “sistema operacional invisível” da ciência moderna.

O pinguim no topo do mundo

Quase todos os supercomputadores que aparecem em rankings internacionais rodam alguma variante de Linux. Faz sentido, pesquisadores precisam de algo que seja estável, flexível e barato de escalar para milhares de máquinas. Licenciar sistema para cada nó de um cluster gigantesco seria impraticável, controlar o comportamento de cada detalhe do kernel, ou núcleo do sistema operacional, dos drivers e da rede é essencial, e o Linux entrega isso.

Imagine um laboratório que simula o clima da Terra nas próximas décadas. Cada “rodada” de simulação envolve trilhões de operações matemáticas acontecendo em paralelo. O que coordena essa dança entre milhares de processadores é um sistema operacional capaz de ser ajustado como uma peça de laboratório: recompilar o kernel, trocar agendador de processos, ajustar pilhas de rede, tudo faz diferença.

Quando se fala em avanços científicos recentes, modelos climáticos mais precisos, genomas montados em tempo recorde, imagens de buracos negros, robôs cirúrgicos, veículos autônomos, novos materiais, quase sempre há uma história técnica por trás. Nessa história, o pinguim do Linux aparece discretamente, no canto da cena, mas com papel fundamental.

É ele que mantém as máquinas conversando, os dados fluindo, os experimentos rodando. Invisível para o público geral, onipresente para quem vive o dia a dia da pesquisa. E, para qualquer pessoa curiosa o suficiente para abrir um terminal pela primeira vez, é também uma porta de entrada para esse universo.

É o tipo de liberdade que, hoje, praticamente só existe nesse grau em sistemas baseados em Linux.

Da bancada molhada ao código: bioinformática

A cena clássica da biologia ainda tem bancada, tubos e pipetas, mas uma parte enorme do trabalho migrou para arquivos de texto e scripts. Ler o genoma de uma bactéria, comparar mutações de um tumor, montar árvores evolutivas: tudo isso envolve processar quantidades absurdas de dados.

Ferramentas que se tornaram padrão na bioinformática, para alinhamento de sequências, montagem de genomas, análise de expressão gênica, geralmente foram escritas primeiro pensando em Linux. Muitas são distribuídas como código aberto, prontas para serem compiladas num servidor do laboratório ou num cluster de universidade.

O ciclo costuma ser assim: alguém desenvolve um novo método, publica o artigo e libera o software no GitHub, um repositório com milhares de códigos. Outros grupos, às vezes em outros continentes, baixam o código, rodam em suas próprias máquinas Linux, testam com seus dados e apontam melhorias. O sistema operacional, nesse contexto, vira um idioma comum entre biólogos, médicos, estatísticos e programadores.

Aprendizado de máquina e a nova “vidraça” da pesquisa

Quando se fala em modelos complexos de aprendizado de máquina, a imagem mental é de GPUs poderosas e grandes centros de dados. Por trás dessas placas, quase sempre, está um servidor rodando Linux. Bibliotecas como PyTorch e TensorFlow nasceram e amadureceram nesse ambiente. Drivers de GPU, ferramentas de gerenciamento de recursos e integração com clusters HPC funcionam melhor lá.

Para o pesquisador, isso se traduz em algo muito concreto: menos atrito entre a ideia e o experimento. Em vez de brigar com incompatibilidades de driver ou limitações do sistema, a pessoa instala o que precisa com o gerenciador de pacotes, configura o ambiente e começa a treinar o modelo.

O mais interessante é que essa mesma base serve tanto para um grande laboratório quanto para um estudante com um notebook mais simples. A diferença está na escala, não na lógica. O script que testa um modelo pequeno em casa é, conceitualmente, o mesmo que roda em dezenas de GPUs num centro de pesquisa.

Robôs, satélites e telescópios: Linux fora da tela

Nos laboratórios de robótica, é comum ver pequenas placas embarcadas controlando motores, sensores e câmeras. Muitas rodam distribuições Linux adaptadas, com sistemas como o ROS (Robot Operating System) por cima. A vantagem é clara: o que se aprende controlando um braço robótico simples pode ser levado, em escala, para projetos mais ambiciosos.

O mesmo vale para satélites e sondas, não é raro encontrar variações de Linux em sistemas de bordo, responsáveis por coletar dados, gerenciar comunicação e executar comandos enviados da Terra. No controle em solo, estações recebem esses dados e os processam também em servidores Linux.

Em observatórios astronômicos, scripts em shell e Python orquestram sequências de observação, coordenam o movimento de telescópios, armazenam imagens e alimentam pipelines de redução de dados. Mais uma vez, a interface gráfica pode até ser bonita, mas o “chão de fábrica” é um conjunto de programas simples rodando em cima de um sistema enxuto e confiável.

Reprodutibilidade: ciência que outros conseguem refazer

Um dos problemas centrais da ciência contemporânea é a reprodutibilidade. Não basta publicar um resultado, é preciso que outra equipe, com acesso a dados semelhantes, consiga refazer o experimento e obter algo compatível.

Linux entra nessa história como parte do esforço de padronizar ambientes. É muito mais fácil dizer “rodei este código numa distribuição X, com tais versões de bibliotecas”, ou até empacotar tudo em um container, do que tentar descrever um ambiente heterogêneo e fechado.

Ferramentas de containerização e virtualização, que permitem empacotar dependências, versões de bibliotecas e configurações, nasceram ou ganharam maturidade nesse ecossistema. Assim, o que foi executado num servidor de um instituto pode ser replicado num cluster de universidade em outro país com muito menos incerteza.

Essa previsibilidade não é detalhe técnico; é um pilar de confiança nos resultados científicos.

Cultura de colaboração: o que o código aberto ensina à ciência

Linux não é apenas um sistema operacional, é o resultado de milhões de contribuições, de gente espalhada pelo mundo, ajustando detalhes, corrigindo erros, criando drivers, escrevendo documentação. Essa forma de construir software inspirou diretamente a maneira como muitos grupos de pesquisa lidam com seus próprios códigos.

Repositórios públicos com scripts de análise, notebooks comentados, documentação em Markdown, tudo isso conversa diretamente com a cultura que já existia no mundo do software livre. A ideia de que o valor está não apenas no resultado, mas também no “como” se chegou lá, cria um ambiente onde compartilhar o código da pesquisa é quase tão natural quanto compartilhar os dados.

Em muitas áreas, publicar um trabalho sem disponibilizar o código associado começa a soar estranho. E, quando esse código é escrito pensando em rodar em Linux, a barreira para adoção é menor, porque o ambiente é conhecido de laboratórios, universidades e até empresas.

O estudante, o terminal e o futuro

Para muitos, o primeiro contato com Linux é: um computador velho reutilizado, um dual-boot em casa, uma máquina virtual para aprender programação. Parece algo pequeno, quase um hobby técnico. Mas, para quem está entrando em áreas como física, biologia computacional, ciência de dados ou robótica, essa familiaridade inicial pode se transformar em vantagem concreta.

Saber navegar pelo terminal, entender o básico de permissões, processos, pacotes, montar e desmontar discos, compilar um programa: todas essas pequenas habilidades formam um alfabeto que, mais tarde, permite ler a linguagem cotidiana dos grandes laboratórios.

O Linux está menos ligado à ideia de “sistema alternativo” e mais à noção de ferramenta de trabalho. Ele virou, para a ciência, algo semelhante ao que o caderno de laboratório foi em outras épocas: um espaço onde ideias são testadas, corrigidas, anotadas e compartilhadas.

Leia Mais

Informação é teletransportada entre fótons pela primeira vez

Durante o dia, notícias sobre golpes digitais, vazamento de dados e contas bancárias invadidas dominam as manchetes. Em paralelo, num laboratório na Alemanha, um grupo de físicos está literalmente teleportando estados quânticos de luz entre fontes diferentes. Aparentemente são dois mundos distantes, mas na prática estão conectados pela mesma pergunta: como proteger informação em um ambiente online cada vez mais vulnerável?

A vida conectada continua exposta. Golpistas conseguem se passar por alguém da família, clonar perfis, acessar contas financeiras com truques cada vez mais sofisticados. Ferramentas de inteligência artificial ajudam criminosos a criar mensagens convincentes, imitar vozes, gerar documentos falsos e planejar ataques bem direcionados. Tudo isso torna a proteção dos dados uma corrida constante de defesa e contra-ataque.

É nesse cenário que entra a tal “criptografia quântica”, um termo que pode soar meio futurista, mas que se apoia em princípios sólidos da física. A ideia central é simples, embora sofisticada na prática: usar propriedades quânticas da luz para codificar informações de forma que qualquer tentativa de espionagem deixe marcas visíveis no sinal. Em vez de confiar apenas em cálculos difíceis de quebrar, a segurança se apoia nas próprias regras da natureza.

Só que transformar essa ideia em infraestrutura real não é trivial. Um “internet quântica” funcional precisa de uma série de componentes que ainda estão em desenvolvimento. Entre eles, um é considerado crucial: o repetidor quântico, o equivalente, no mundo quântico, dos amplificadores que já existem nas fibras ópticas comuns. E foi justamente nessa peça do quebra-cabeça que um grupo de pesquisadores da Universidade de Stuttgart deu um passo importante.

O trabalho foi conduzido no Instituto de Óptica de Semicondutores e Interfaces Funcionais (IHFG) da Universidade de Stuttgart. A equipe, coordenada pelo professor Peter Michler, conseguiu teleportar informação quântica entre fótons emitidos por dois pontos quânticos diferentes, isto é, duas fontes de luz independentes em semicondutores. O resultado foi publicado na revista Nature Communications e é visto como um marco rumo a repetidores quânticos práticos.

Nas comunicações digitais clássicas, qualquer mensagem — de um e-mail a um vídeo em streaming, é quebrada em sequências de zeros e uns, os bits. Esses bits viajam pela rede em forma de pulsos de luz dentro de fibras ópticas. No caso da comunicação quântica, a lógica de “zero” e “um” permanece, mas quem carrega a informação é um fóton individual, um único “pedaço” de luz.

Esse fóton pode codificar zero, um ou uma combinação dos dois ao mesmo tempo em uma propriedade chamada polarização. Em termos mais visuais, dá para imaginar o fóton como uma flecha de luz que pode apontar na direção horizontal, na vertical ou em uma mistura das duas orientações. Esse estado é delicado e não pode ser medido sem ser alterado. Quando alguém tenta “espiar” o fóton para descobrir o que ele carrega, o ato de medir inevitavelmente modifica o estado. É justamente isso que permite detectar a presença de um intruso.

Essa característica é o coração da criptografia quântica. Se emissor e receptor observam que os estados quânticos usados para gerar uma chave secreta chegaram intactos, eles ganham confiança de que ninguém interceptou o caminho. Se algo parece alterado, o canal é considerado comprometido e a chave é descartada.

Na prática, porém, existe outro problema: a distância. As redes de fibra óptica que sustentam a internet tradicional não são perfeitas. Mesmo em cabos de boa qualidade, a luz vai perdendo força com o caminho, até sumir. Em comunicações clássicas, a solução é simples: a cada certas dezenas de quilômetros, algo como 50 km, entram em cena amplificadores ópticos que leem o sinal, copiam a informação e reenviam um pulso novo e forte.

No universo quântico, essa receita não funciona. Estados quânticos não podem ser copiados à vontade, sob pena de violar uma regra fundamental da teoria, conhecida como teorema da não clonagem. Não existe o “ler, copiar e reenviar” sem destruir o próprio estado original. Surge então a pergunta: como renovar um sinal quântico frágil sem quebrar as regras da física?

A solução proposta pela física quântica é engenhosa: em vez de copiar, é possível transferir o estado de um fóton para outro sem nunca observar diretamente a informação codificada. Esse processo é chamado de teletransporte quântico. O nome lembra ficção científica, mas aqui não se trata de mandar matéria de um lugar a outro. O que “viaja” é a configuração quântica, o padrão de informação que define o qubit.

Para isso funcionar, entra em jogo outro conceito importante: o emaranhamento. Quando duas partículas estão emaranhadas, elas formam um único sistema quântico, mesmo que estejam separadas por grandes distâncias. Medir uma delas afeta instantaneamente a descrição da outra, de forma que os resultados sempre aparecem correlacionados. É como se fossem duas faces de uma mesma moeda, guardadas em cofres diferentes, mas que insistem em se comportar de maneira coordenada.

Os repetidores quânticos se apoiam justamente nessa combinação de emaranhamento e teletransporte. Eles funcionariam como nós intermediários, gerando pares emaranhados de fótons e usando essas correlações para transferir estados quânticos de um ponto da rede a outro, “refrescando” a informação antes que ela se perca na fibra. Só que para isso tudo dar certo é preciso que os fótons envolvidos sejam praticamente indistinguíveis: mesma cor, mesmo perfil temporal, mesma forma de pulso. Aí começa a parte realmente delicada.

A equipe de Stuttgart trabalha com pontos quânticos, que são pequenas “ilhas” de semicondutor com tamanho na escala de nanômetros. Dentro dessas ilhas, existem níveis de energia quantizados, um pouco como acontece em átomos. Quando o sistema é excitado de forma controlada, pode emitir fótons um por um, com propriedades bem definidas. É uma fonte de luz feita sob medida para o mundo quântico.

O desafio é que cada ponto quântico, mesmo fabricado com muito cuidado, tende a ser ligeiramente diferente. Essas pequenas variações levam a fótons com cores e frequências que não batem exatamente. O grupo de Stuttgart trabalhou em colaboração com o Instituto Leibniz de Pesquisa de Estado Sólido e Materiais, em Dresden, para produzir pontos quânticos quase idênticos, com diferenças mínimas entre si. O objetivo era claro: gerar fótons praticamente iguais em dois lugares diferentes.

Com essas fontes em mãos, a equipe montou o experimento. Em uma das amostras, um ponto quântico produz um único fóton cuja polarização carrega a informação quântica a ser teleportada. Em outra, um segundo ponto quântico gera um par de fótons emaranhados. Um desses fótons emaranhados é enviado, por fibra óptica, para o local onde está o fóton “mensageiro” inicial. Os dois se encontram e interferem um com o outro em um arranjo experimental específico.

Quando essa interferência ocorre da forma correta, certas detecções combinadas dos fótons indicam que o estado do fóton original foi transferido para o parceiro distante do par emaranhado, que ficou em outro ponto da rede. Ninguém precisou medir diretamente a polarização que carregava a informação, mas essa polarização agora está “impressa” em um novo fóton, em outro lugar. É isso que se chama teletransporte quântico de estado.

Nada disso seria possível se os fótons fossem muito diferentes entre si. Para resolver as diferenças residuais de frequência entre as duas fontes, o experimento contou com “conversores quânticos de frequência”. Esses dispositivos ajustam a cor dos fótons de forma precisa, de modo que os pulsos de luz que vêm de pontos quânticos distintos passem a ser praticamente indistinguíveis. Essa parte da pesquisa foi liderada pelo grupo do professor Christoph Becher, especialista em óptica quântica na Universidade do Sarre.

O resultado final foi a primeira demonstração de que se consegue teleportar informação quântica entre fótons produzidos por pontos quânticos diferentes. Em termos de infraestrutura, é como provar que é possível “conversar” de forma quântica usando blocos de construção semicondutores separados, algo essencial se a ideia é um dia espalhar repetidores quânticos por uma rede de fibras já existente.

Por enquanto, o experimento foi realizado com uma distância relativamente modesta: os pontos quânticos estavam conectados por cerca de 10 metros de fibra óptica. O grupo, no entanto, já havia mostrado em trabalhos anteriores que os fótons emitidos por esses sistemas podem manter o emaranhamento mesmo depois de percorrer 36 quilômetros de fibras através da cidade de Stuttgart. A expectativa é empurrar esses limites cada vez mais para frente, aproximando o laboratório das condições encontradas em redes reais.

Outro ponto importante é a taxa de sucesso da teleportação, que hoje está um pouco acima de 70%. Flutuações nos pontos quânticos ainda geram pequenas diferenças entre os fótons e reduzem a eficiência geral. Melhorar técnicas de fabricação de semicondutores, estabilizar o ambiente dos dispositivos e refinar a eletrônica de controle são caminhos para aumentar esse número. Pesquisadores como Tim Strobel e Simone Luca Portalupi, que lideram partes do projeto, enfatizam que o experimento é fruto de anos de trabalho incremental e refino técnico.

Diante de tudo isso, surge uma questão inevitável: o que esse tipo de avanço significa para o mundo concreto de senhas vazadas e golpes por mensagem, que continua se desenrolando no dia a dia de qualquer usuário comum?

Uma rede quântica robusta, com repetidores espalhados e criptografia baseada em fótons individuais, promete um tipo de segurança que não depende apenas de quão rápido um computador consegue quebrar códigos. A proteção viria da própria impossibilidade física de copiar estados quânticos sem deixar rastros. Em um cenário em que técnicas de inteligência artificial podem acelerar a quebra de certos sistemas clássicos, essa mudança de paradigma ganha apelo.

Ao mesmo tempo, o próprio estado da arte mostra que essa visão ainda está em construção. Experimentos controlados em laboratório, com distâncias de alguns quilômetros ou dezenas de quilômetros, não se traduzem automaticamente em redes globais, integradas às infraestruturas atuais. Custos, padronização, integração com sistemas existentes, manutenção e toda a camada de “mundo real” ainda precisam ser encarados.

Talvez a leitura mais interessante desse tipo de resultado seja menos a ideia de uma solução mágica e mais a percepção de que a arquitetura da segurança digital está em plena transformação. Criptografia clássica continua fundamental, práticas básicas de proteção de dados seguem indispensáveis, e políticas de segurança ainda são tão importantes quanto qualquer inovação tecnológica. As pesquisas em comunicação quântica entram como um próximo degrau, preparando o terreno para uma camada adicional de proteção em um futuro em que a informação, cada vez mais, é o recurso mais sensível que circula pela rede.

Entre golpes sofisticados e experimentos de teletransporte de fótons, o mundo digital parece dividido em dois extremos, porém, os dois lados dialogam. Ao tornar visível a fragilidade das defesas atuais e ao apontar caminhos baseados em novas leis físicas, a física quântica não resolve todos os problemas, mas amplia o horizonte de possibilidades. O desafio é acompanhar esse movimento com olhar crítico, sem expectativas milagrosas, mas com a consciência de que a segurança da informação será, cada vez mais, um campo em que ciência de ponta e vida cotidiana se encontram.

---

Referências:

Telecom-wavelength quantum teleportation using frequency-converted photons from remote quantum dots - A internet quântica global é baseada em redes escaláveis, que exigem hardware quântico confiável. Entre esses dispositivos estão fontes de luz quântica capazes de fornecer fótons emaranhados determinísticos, de alta intensidade e alta fidelidade, além de memórias quânticas com tempos de coerência superiores à faixa dos milissegundos. A operação a longas distâncias requer fontes de luz quântica que emitam em comprimentos de onda de telecomunicações. Um pilar fundamental para tais redes é a demonstração da teletransmissão quântica. Aqui, realizamos teletransmissão quântica totalmente fotônica empregando pontos quânticos semicondutores, que podem atender a todos os requisitos mencionados. Dois pontos quânticos remotos de GaAs, que emitem no infravermelho próximo, são utilizados: um como fonte de pares de fótons emaranhados e o outro como fonte de fóton único. Durante o experimento, o fóton único é preparado em estados de polarização conjugados e interage com a emissão biexcitônica do par emaranhado por meio de uma medida de estado de Bell seletiva em polarização. https://www.nature.com/articles/s41467-025-65912-8

Leia Mais

Conhecendo IoT (Internet of Things), Internet das Coisas

Imagina uma cena simples, que poderia estar em qualquer interior do Brasil. À beira de um rio, um pequeno equipamento preso a uma estaca fica ali em silêncio, dia e noite, sob sol forte e chuva pesada. Ele não tem tela colorida, não faz barulho, ninguém tira selfie com ele. Mesmo assim, esse caixotinho discreto mede a qualidade da água, registra a temperatura, percebe mudanças na correnteza e manda esses dados para pesquisadores a centenas de quilômetros dali. Dentro dele, quem está trabalhando sem aparecer na foto é uma combinação curiosa, a internet das coisas com um sistema Linux enxuto, montado sob medida para viver longe de qualquer laboratório tradicional.

A expressão internet das coisas pode soar abstrata em um primeiro momento, mas o conceito é menos complicado do que parece. Em vez de computadores e celulares, quem entra na rede são objetos do dia a dia, sensores, válvulas, lâmpadas, semáforos, colares de gado, câmeras de baixo custo, medidores de energia, estações meteorológicas. Cada um desses aparelhos ganha memória, capacidade de processar informação e conexão, geralmente via rede de celular, satélite ou Wi-Fi. Quando esse pacote chega até o campo da ciência, nasce uma pequena revolução na maneira de enxergar o mundo em tempo real.

Do outro lado dessa história está o Linux, um sistema operacional que começou como projeto de comunidade e hoje roda em supercomputadores, servidores de grandes empresas, celulares e, de forma quase invisível, em milhões de aparelhos espalhados pelo planeta. No universo dos sensores científicos, ele aparece em versões mais enxutas, chamadas de Linux embarcado, pensadas para funcionar em placas pequenas, com pouca memória, muitas vezes instaladas em locais sem energia estável, nem ar condicionado, nem técnico por perto. É esse casamento entre pequenos sensores, conectividade e Linux que está criando uma nova infraestrutura para a ciência moderna.

Quando falamos em monitoramento ambiental e ciência de campo, a importância desse trio fica ainda mais evidente. Pesquisar um rio, uma floresta, um manguezal, um deserto ou uma região costeira sempre exigiu deslocamentos, equipes em campo, cadernos de anotação, coleta manual de amostras, retorno ao laboratório, análises demoradas. Agora, parte desse trabalho passa a ser contínuo e automatizado. Em vez de uma visita pontual por mês, sensores equipados com Linux podem enviar medições de hora em hora, ou até de minuto em minuto, oferecendo um retrato muito mais fiel de como o ambiente se comporta ao longo do tempo.

Um exemplo concreto ajuda a visualizar melhor. Imagine uma rede de sensores instalados ao longo de um rio que abastece uma cidade grande. Em cada ponto, um pequeno módulo mede a turbidez da água, a presença de determinados compostos químicos e a temperatura. Dentro desse módulo existe uma plaquinha de baixo consumo rodando Linux, responsável por organizar as leituras, fazer uma primeira filtragem dos dados, descartar o que estiver claramente errado e compactar o restante. Esses pacotes de informação são enviados por rádio ou pela rede de celular para um computador central, onde sistemas mais robustos fazem análises estatísticas, geram alertas e alimentam modelos de previsão.

É aqui que entra a ideia de computação de borda, termo que circula cada vez mais em reportagens sobre tecnologia, mas que pode ser explicado de maneira simples. Em vez de mandar tudo que o sensor vê diretamente para a nuvem, o próprio dispositivo faz parte do trabalho pesado ali na ponta, na borda da rede. Filtrar, agregar, comprimir, tomar pequenas decisões automáticas, tudo acontece antes de os dados saírem do campo. Esse tipo de inteligência local é importante porque nem sempre há banda de internet suficiente, nem energia sobrando, nem tempo para mandar tudo para um data center distante e esperar uma resposta.

Linux combina bem com esse cenário porque foi desenhado para ser flexível. Em muitos projetos científicos, os desenvolvedores montam uma distribuição mínima, removendo programas desnecessários, deixando apenas o que interessa para o sensor funcionar com estabilidade. Há quem use ferramentas como Yocto ou Buildroot para montar esse sistema sob medida, quase como um alfaiate que corta o tecido na exata medida do corpo do cliente. Com isso, um único cartão de memória de poucos gigabytes consegue abrigar o sistema operacional, o software de coleta de dados, mecanismos de segurança e ainda manter um espaço para registrar leituras e logs.

Essa inteligência na borda da rede não serve apenas para economizar internet. Em situações de risco, como enchentes, deslizamentos, queimadas ou vazamentos de substâncias tóxicas, o tempo de reação faz diferença. Um sensor programado para detectar uma alteração brusca em um parâmetro importante pode emitir um alerta imediato, acionar sirenes locais ou mandar mensagens para equipes de defesa civil, sem depender de uma conexão impecável até a nuvem. O sistema Linux ali dentro permite programar esses comportamentos com relativa facilidade, usando linguagens como Python, C ou scripts de shell, que muitos pesquisadores e técnicos já conhecem.

Do ponto de vista da ciência de dados, esse fluxo também muda o jogo. Em vez de planilhas soltas e arquivos dispersos em pendrives, passa a existir um pipeline mais organizado. Os dados saem dos sensores, passam pelos pequenos computadores de borda, que rodam Linux, seguem para servidores centrais e, em muitos casos, desembocam em plataformas de big data. Nesse caminho, entram ferramentas que nasceram no mesmo ecossistema, como bancos de dados de código aberto, sistemas de mensagens do tipo MQTT e ambientes de contêineres, com Docker ou podman, que permitem encapsular o software e replicá-lo em várias máquinas sem sustos.

Essa integração com infraestrutura de big data é particularmente valiosa na ciência moderna, que vive um momento de abundância de informações e escassez de tempo para analisá-las. Projetos de monitoramento ambiental com internet das coisas não produzem apenas um gráfico bonito, produzem séries históricas densas, com milhões de pontos registrados. Cruzar essas séries com dados de satélite, registros de estações meteorológicas, imagens de drones e informações socioeconômicas abre espaço para perguntas que antes eram impossíveis de formular, simplesmente porque não existiam registros suficientes para testá-las.

Dentro dos laboratórios, a lógica não é tão diferente. Quem já passou por um laboratório universitário ou de instituto de pesquisa sabe como equipamentos caros convivem com adaptações caseiras, sensores improvisados, cabos que só o técnico mais antigo entende. Nesse ambiente, trazer a internet das coisas com Linux ajuda a colocar ordem no caos. Aparelhos de medição podem ser ligados a controladores que registram cada leitura de forma automática, experimentos de longa duração podem ser acompanhados remotamente, dados podem ir direto para servidores de análise, reduzindo a dependência de anotações em cadernos físicos, que se perdem com facilidade.

Instrumentação científica automatizada não serve apenas para modernizar o laboratório. Ela reduz o risco de erros humanos, abre espaço para repetir experimentos com mais fidelidade, permite que equipes pequenas controlem vários setups ao mesmo tempo e cria uma trilha de auditoria, onde cada mudança de parâmetro, cada falha de energia, cada interrupção fica registrada. Em áreas sensíveis como pesquisas clínicas, estudos sobre qualidade da água ou monitoramento de poluição, essa rastreabilidade é uma garantia importante de que os dados podem ser confiáveis, algo valioso em discussões públicas e processos regulatórios.

Fora das paredes dos laboratórios, o impacto também aparece na agricultura, que há anos vem adotando sensores e conectividade como ferramentas de trabalho. Em lavouras de médio e grande porte, pequenos dispositivos instalados no solo medem umidade, temperatura, salinidade e outros fatores que influenciam o crescimento das plantas. Com apoio de um sistema Linux na borda, esses dados alimentam sistemas de irrigação inteligentes, que ligam e desligam bombas de água na hora certa, com base em regras programadas ou modelos mais sofisticados. O resultado é uma produção mais eficiente, com menos desperdício de água e fertilizantes, algo fundamental em um cenário de mudanças climáticas e pressão por aumento de produtividade.

Nas cidades, a combinação de sensores, IoT e Linux aparece em projetos de mobilidade, iluminação pública, qualidade do ar e gestão de resíduos. Postes equipados com sensores podem medir poluição sonora, registrar variações de luminosidade e até contar o fluxo de pedestres e veículos em determinados cruzamentos. Placas de rua discretas, sem nenhum glamour tecnológico aparente, rodam pequenas distribuições Linux, tratam esses dados localmente e enviam apenas o essencial para servidores centrais. A partir dessa base, surge a possibilidade de planejar melhor o transporte público, revisar rotas de caminhões de lixo, ajustar horários de semáforos e identificar áreas com maior exposição a poluentes.

Em muitos casos, quem dá o primeiro passo não são grandes empresas de tecnologia, e sim grupos de pesquisadores, estudantes e entusiastas reunidos em hackerspaces e laboratórios de inovação. Com placas baratas, sensores acessíveis e sistemas Linux de código aberto, esses grupos montam protótipos de estações meteorológicas, redes de monitoramento de enchentes, medidores caseiros de qualidade do ar. Esses projetos começam pequenos, mas funcionam como laboratório vivo para formar gente capaz de trabalhar em iniciativas maiores, públicas ou privadas. Também ajudam a aproximar o tema da sociedade, porque mostram que essa infraestrutura invisível pode ser construída de maneira colaborativa, e não apenas comprada pronta em catálogos de fornecedores internacionais.

Quem controla essa infraestrutura de sensores conectados, que está se espalhando silenciosamente por rios, florestas, plantações e cidades. Em muitos projetos acadêmicos, o código é aberto, o hardware é documentado e a intenção é clara, ampliar o conhecimento científico. Em outros contextos, porém, o mesmo tipo de tecnologia pode ser usado para vigilância, para controle de trabalhadores, para exploração intensiva de recursos naturais. O fato de Linux ser aberto e de fácil adaptação não garante por si só que será usado para fins nobres, apenas torna a ferramenta mais acessível.

Existe ainda um lado geopolítico nessa conversa, que raramente aparece nos anúncios de produtos. Países que dependem apenas de caixas pretas compradas de grandes fornecedores correm o risco de ficar presos a contratos caros e soluções fechadas. Ao escolher uma base tecnológica como Linux para seus projetos de internet das coisas na ciência, instituições de pesquisa e universidades ganham margem de manobra, podem formar equipes locais capazes de manter e adaptar o sistema, podem criar soluções próprias para monitorar seus biomas e suas cidades, sem depender totalmente de software estrangeiro que não dialoga com a realidade local.

Por outro lado, não faltam desafios concretos, manter milhares de sensores espalhados por áreas remotas exige planejamento, peças de reposição, energia confiável, redes de comunicação minimamente estáveis. Montar distribuições Linux enxutas para rodar em hardware frágil pede conhecimento técnico que ainda não é tão difundido. Garantir segurança, atualizar sistemas de forma remota, impedir invasões e fraudes em dispositivos que ficam abandonados à beira de estradas ou no meio da mata é tarefa complexa, que mistura engenharia, criptografia, políticas públicas e recursos financeiros.

À medida que o custo de sensores cai, que placas de processamento ficam mais poderosas e baratas e que conectividade se espalha, cresce o número de projetos que tratam rios, florestas, cidades e laboratórios como grandes redes de dados. Linux, com sua tradição de flexibilidade, segurança e comunidade ativa, tende a continuar no centro dessa transformação, servindo ao mesmo tempo de alicerce para experimentos improvisados em universidades e de base confiável para projetos industriais de grande porte.

Quem ganha com esse encontro entre internet das coisas, Linux e ciência de ponta é a capacidade coletiva de enxergar o que antes passava despercebido. Um aumento sutil na acidez de um lago, uma variação estranha na vibração de uma ponte, uma sequência de noites mais quentes em um fragmento de floresta urbana, tudo isso pode virar dado, gráfico, alerta e, com algum esforço, política pública e mudança de comportamento. Não há sistema operacional que resolva sozinho os dilemas ambientais e sociais do nosso tempo, mas escolhas tecnológicas mais abertas e distribuídas ajudam a colocar o conhecimento científico em circulação, em vez de guardá-lo em laboratórios fechados, longe dos rios, das árvores e das pessoas que vivem ao redor deles. Quando sensores, softwares livres e pesquisadores conseguem trabalhar em conjunto, surge a chance de construir uma espécie de mapa vivo do planeta. Esse mapa não existe apenas nas telas, ele volta para o território em forma de decisões mais informadas.

Leia Mais