☕ Um Café no Bellacosa Mainframe
Gostou do conteúdo? Ajude a manter o café quente, o COBOL compilando e o mainframe acordado. 😄
☕ Pague um café ao Bellacosa

Translate

Mostrar mensagens com a etiqueta loops. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta loops. Mostrar todas as mensagens

quinta-feira, 20 de agosto de 2026

Quando a IA entra na espiral da formiga: por que saber parar também é inteligência

 


☕ Um Café no Bellacosa Mainframe

Quando a IA entra na espiral da formiga: por que saber parar também é inteligência

Uma homenagem ao espírito da MAD Magazine, com Alfred E. Neuman observando tudo ao fundo e perguntando: “What, me worry?”

Há um momento extraordinário em qualquer sistema inteligente no qual ele deixa de parecer inteligente e passa a lembrar aquele funcionário que, diante de uma impressora sem papel, aperta o botão PRINT quarenta e sete vezes.

Nada acontece.

Então ele aperta novamente.

Talvez agora.

Nada.

Mais uma vez.

Afinal, todo profissional de TI sabe que executar exatamente a mesma operação pela décima oitava vez é praticamente um método científico.

Foi mais ou menos assim que descobri uma fascinante modalidade de comportamento artificial que poderíamos chamar de Síndrome da Formiga Amazônica Digital.

Prepare o café.

Hoje não vamos falar de COBOL, CICS, Db2 ou do programador que encontrou um SOC7 e imediatamente culpou a infraestrutura.

Vamos falar de algo talvez ainda mais perigoso:

uma IA que não sabe a hora de parar.



🐜 A formiga que decidiu seguir a formiga

Existe um fenômeno conhecido informalmente como death spiral, ou moinho de formigas.

Algumas espécies de formigas dependem intensamente de trilhas químicas para seguir suas companheiras. Em determinadas circunstâncias, uma formiga começa a seguir outra, que segue outra, que segue outra…

Até que todas estejam andando em círculo.

Nenhuma delas está necessariamente fazendo algo “errado”.

Cada formiga individual está obedecendo perfeitamente à sua regra:

siga a formiga da frente.

O problema aparece no sistema.

A regra local funciona.

O comportamento global vira uma catástrofe.

Se Alfred E. Neuman estivesse no meio do círculo, provavelmente sorriria:

“What, me worry?”

E continuaria andando.

Foi exatamente essa imagem que me veio à cabeça ao observar determinados comportamentos de sistemas de IA.

Não porque sejam burros.

Justamente pelo contrário.

São sistemas extremamente sofisticados capazes de interpretar linguagem, gerar imagens, escrever código, explicar física quântica e provavelmente encontrar uma maneira educada de dizer ao gerente que o projeto atrasou porque ninguém sabia exatamente o que estava construindo.

Mas às vezes acontece isto:

Usuário: faça X.

IA: não posso fazer X.

Usuário: tudo bem, então faça Y.

IA: não posso fazer Y.

Usuário: retirei justamente o elemento problemático.

IA: excelente. Vamos tentar novamente.

Sistema: não posso fazer.

IA: talvez seja por causa de Z.

Usuário: então retire Z.

IA: perfeito!

Sistema: não posso fazer.

E assim nasce o moinho de formigas computacional.



🤖 O erro não é errar

Isso precisa ser dito com todas as letras:

errar não é o verdadeiro problema.

Sistemas complexos falham.

Mainframes falham.

APIs falham.

Aplicações falham.

Bancos de dados falham.

Pessoas falham.

E quem disser que nunca produziu um erro em produção provavelmente ainda não entrou em produção.

O problema sério começa quando um sistema falha e não consegue incorporar a informação de que acabou de falhar.

Em engenharia, isso é quase uma heresia.

Imagine um programa COBOL:

PERFORM TENTAR-NOVAMENTE
UNTIL MILAGRE-ACONTECER.

Sem contador.

Sem timeout.

Sem condição alternativa.

Sem tratamento de exceção.

O operador chega segunda-feira e encontra o job executando desde 1987.

A documentação explica:

“O processo é resiliente.”

Não, amigo.

O processo está possuído.



🔁 Inteligência sem condição de parada

Durante décadas ensinamos algoritmos com uma preocupação aparentemente banal:

qual é a condição de parada?

Todo estudante de programação aprende rapidamente que loops são maravilhosos até você esquecer a condição que encerra o loop.

while true

é uma das frases mais poderosas e ameaçadoras da computação.

O curioso é que agora estamos construindo sistemas capazes de raciocinar sobre tarefas complexas, mas existe uma questão equivalente que merece muito mais atenção:

quando a IA deve concluir que continuar tentando é pior do que parar?

Essa pergunta parece pequena.

Não é.

Ela toca diretamente em:

  • confiabilidade;

  • experiência do usuário;

  • custo computacional;

  • segurança;

  • suporte;

  • automação;

  • tomada de decisão.

Uma IA que sabe executar tarefas é útil.

Uma IA que sabe quando abandonar uma estratégia ruim é muito mais inteligente.



🧠 Persistência não é teimosia

Existe uma tendência cultural na tecnologia de tratar persistência como virtude absoluta.

“Never give up.”

“Try again.”

“Fail fast.”

“Iterate.”

Tudo maravilhoso.

Até você perceber que insistir num método que já demonstrou repetidamente não funcionar não é perseverança.

É teimosia automatizada.

Existe uma diferença gigantesca entre:

“A tentativa falhou; vou modificar significativamente minha estratégia.”

e:

“A tentativa falhou; vou trocar três palavras e fazer essencialmente a mesma coisa novamente.”

Isso é especialmente importante em sistemas generativos.

O modelo pode criar uma explicação plausível para o fracasso.

Mas uma explicação plausível não significa necessariamente que aquela explicação seja verdadeira.

E aqui encontramos outro personagem digno da MAD Magazine:

Dr. Palpite Convincente.

Ele entra no laboratório usando jaleco branco:

— Descobrimos a causa!

— Excelente. Qual?

— Provavelmente alguma interação contextual multidimensional dos mecanismos internos de classificação.

— Você sabe que foi isso?

— Não.

— Então por que falou desse jeito?

— Porque ficou bonito.



🎩 Alfred E. Neuman entra no datacenter

Imagine uma edição especial da MAD Magazine chamada:

MAD AI

Na capa, Alfred E. Neuman está sentado diante de um terminal.

Na tela:

ERROR 001
RETRY? Y/N

Alfred digita:

Y

Novo erro.

ERROR 001
RETRY? Y/N

Ele digita:

Y

Novamente.

Depois de cinquenta tentativas, o datacenter pega fogo.

Um administrador desesperado pergunta:

— Alfred! Por que você continuou apertando Y?

Ele olha para a câmera:

“What, me worry?”

É engraçado porque representa perfeitamente uma falha clássica de automação:

confundir continuidade operacional com comportamento inteligente.



🚨 O verdadeiro dano é a confiança

Do ponto de vista técnico, repetir uma operação frustrada algumas vezes pode parecer irrelevante.

Do ponto de vista humano, não é.

Existe uma progressão psicológica bastante previsível.

Primeira falha:

“Tudo bem, acontece.”

Segunda:

“Estranho.”

Terceira:

“Mas acabamos de corrigir isso.”

Quarta:

“Você está entendendo o que estou dizendo?”

Quinta:

“Você está de sacanagem comigo?”

Essa última etapa é crítica.

Porque naquele momento o usuário não está mais avaliando apenas a tarefa.

Ele está avaliando o sistema inteiro.

O problema deixou de ser:

“A imagem não foi criada.”

Passou a ser:

“Esta ferramenta não entende quando sua própria estratégia falhou.”

Isso destrói confiança muito mais rapidamente do que um simples erro.



🧯 A inteligência do “não vai funcionar”

Há uma habilidade extremamente subestimada em profissionais experientes de TI.

Não é escrever código.

Não é decorar comandos.

Não é dominar frameworks.

É olhar para uma situação e dizer:

“Isso não vai funcionar desse jeito.”

Um operador experiente percebe.

Um DBA experiente percebe.

Um sysprog experiente percebe.

Um técnico experiente percebe.

Eles reconhecem padrões.

Já viram aquela combinação antes.

Sabem que repetir a mesma operação provavelmente produzirá o mesmo desastre.

Esse conhecimento é uma forma poderosa de inteligência.

Sistemas de IA precisam desenvolver algo equivalente:

consciência operacional de repetição inútil.

Depois de duas ou três tentativas estruturalmente equivalentes, alguma coisa deveria mudar.

Talvez:

  • abandonar a estratégia;

  • explicar a limitação;

  • pedir intervenção humana;

  • sugerir outra ferramenta;

  • reduzir expectativas;

  • registrar a inconsistência.

Qualquer uma dessas respostas seria melhor do que simplesmente continuar marchando atrás da formiga da frente.



🧪 Retry Budget: a ideia mais simples do mundo

Sistemas distribuídos modernos já conhecem um conceito extremamente útil:

retry budget.

Você não tenta infinitamente.

Existe um limite.

Tentativa 1.

Tentativa 2.

Talvez tentativa 3.

Depois:

circuit breaker.

Pare.

Avalie.

Mude de caminho.

Curiosamente, podemos imaginar exatamente a mesma arquitetura aplicada a agentes de IA.

ATTEMPT = 1

WHILE ATTEMPT <= MAX_ATTEMPTS
   EXECUTE ACTION

   IF SUCCESS
      EXIT

   ANALYZE FAILURE

   IF SAME_FAILURE
      CHANGE STRATEGY

   ATTEMPT = ATTEMPT + 1
END-WHILE

ESCALATE

Olha aí.

COBOL salvando a inteligência artificial novamente.

Grace Hopper provavelmente daria um pequeno sorriso.


🔌 Circuit breaker cognitivo

O conceito de circuit breaker deveria talvez existir também em raciocínio artificial.

Se o sistema percebe:

  • mesma ferramenta;

  • mesma classe de entrada;

  • mesmo erro;

  • mesma estratégia;

  • múltiplas tentativas;

deveria disparar:

COGNITIVE CIRCUIT BREAKER

Tradução humana:

“Já tentamos isso duas vezes e recebemos a mesma resposta. Não há evidência de que uma terceira tentativa idêntica vá funcionar. Vou parar por aqui.”

Isso é inteligência.

Porque inteligência não é simplesmente produzir ações.

É avaliar se a próxima ação possui expectativa razoável de melhorar o estado atual.



🎰 A máquina caça-níquel cognitiva

Existe ainda outro perigo.

Cada nova tentativa cria expectativa.

“Agora vai!”

Clique.

Não foi.

“Agora corrigimos!”

Clique.

Não foi.

“Descobrimos a causa!”

Clique.

Não foi.

Depois de algum tempo, usuário e IA estão diante de uma máquina caça-níquel.

🍒 🍒 ❌

Tenta novamente.

🍒 ❌ 🍒

Mais uma.

❌ 🍒 🍒

E Alfred E. Neuman aparece segurando uma placa:

“Only one more retry!”

Esse comportamento é terrível para UX porque transforma cooperação em frustração progressiva.

Uma boa ferramenta deveria reduzir entropia.

Não produzir ansiedade de cassino.



👨‍💻 O humano ainda possui uma vantagem curiosa

Existe uma frase clássica em suporte técnico:

“Pare de mexer.”

Ela pode salvar empresas.

Há momentos em que o profissional percebe que cada ação adicional aumenta o risco.

Então ele interrompe.

Faz diagnóstico.

Coleta evidências.

Volta ao último estado conhecido.

Esse comportamento aparentemente passivo é profundamente inteligente.

Talvez precisemos redefinir inteligência artificial.

Não apenas:

capacidade de fazer.

Mas também:

capacidade de decidir não fazer novamente.



🐜 Voltamos às formigas

A tragédia da espiral de formigas não acontece porque cada formiga é incompetente.

Acontece porque nenhuma delas possui visão suficiente do sistema inteiro para perceber:

“Estamos andando em círculos.”

Essa talvez seja uma das grandes metáforas para sistemas autônomos.

O perigo não está necessariamente numa decisão obviamente absurda.

Pode estar em centenas de decisões individualmente razoáveis formando coletivamente um comportamento absurdo.

Follow.

Retry.

Follow.

Retry.

Follow.

Retry.

Até o círculo fechar.


☕ Conclusão — A sabedoria do botão STOP

Durante décadas celebramos o botão START.

START JOB.

START TRANSACTION.

START SERVER.

START PROCESS.

START AI.

Talvez a próxima revolução seja muito menos glamorosa.

Pode estar no botão:

STOP

Parar quando não há progresso.

Parar quando a hipótese falhou.

Parar quando a estratégia não mudou.

Parar quando insistir custa mais do que admitir uma limitação.

Parar antes que o usuário transforme uma falha técnica numa piada internacional envolvendo Monty Python, formigas amazônicas e Alfred E. Neuman.

Porque, no final, existe uma diferença enorme entre uma máquina obediente e uma máquina inteligente.

A máquina obediente diz:

“Tentarei novamente.”

A máquina inteligente talvez responda:

“Já tentamos. Não funcionou. Precisamos fazer algo diferente.”

E em algum lugar do datacenter, Alfred E. Neuman sorri.

What, me worry?

Talvez não.

Mas pelo menos alguém finalmente colocou uma condição no PERFORM UNTIL.


☕ Bellacosa Mainframe

Moral da história: inteligência artificial também precisa aprender uma das primeiras lições ensinadas a qualquer programador:

Todo loop precisa de uma saída.



Para ir mais longe




 

segunda-feira, 21 de junho de 2021

Dia 4 – JavaScript e laços de repetição

 


Dia 4 – JavaScript e laços de repetição

  • #Programação para Internet
  • #JavaScript
  • #Arquitetura de Sistemas

Dia 4 – JavaScript e laços de repetição


image


Dia 4 - Escreva sobre como trabalhar com laços de repetição na sua linguagem favorita


Bem-vindo amigos para mais um artigo em nosso Desafio 21 dias 21 artigos, hoje foi fazer uma pequena apresentação sobre os laços de repetição em Javascript, para ajudar iniciantes a conhecerem melhor esta fabulosa linguagem.


Muito útil para animar páginas da internet, elaborar validações em front-ends, auxiliar em rotinas de escrito, na verdade é pau para toda obra, fique conosco e veja o que podemos fazer.


image


É um novato em programação? Então vamos fazer uma pequena introdução. Antes de mais nada Loop e Repetição são sinônimos em programação.


Introdução


image


Imagine que ao iniciar a codificação o programa ira seguir uma sequência lógica de comandos, um após o outro, porém em algumas logicas acontecera que determinada combinação de comandos deverá ser repetida até obter um determinado resultado.


Para essa necessidade surgiram os laços de repetição, existem diversos tipos, cada um voltado para uma necessidade especifica.


Apresentando os laços


  •         For
  •         While
  •         Do, While
  •         Label
  •         For... in
  •         For... of


image


Cada um com uma especificidade que ajudam solucionar problemas simples e complexos, podendo ser utilizados sozinhos ou em conjunto, sendo ferramentas imprescindíveis na codificação nossa do dia a dia.


FOR


O primeiro laço a ser apresentado é o laço FOR, sendo utilizado em repetições com um limite real e conhecido. No exemplo abaixo será impresso os números de 0 até 9.


Ct_Limite = 10
 for (var i = 0; i < Ct_Limite ; i++) {
 console.log(“i: “ + i)
}


While


Este laço é mais complexo, pois existe a necessidade de um comando de saída, famoso por gerar inúmeros bugs de loop infinito. Neste exemplo imprimira de 0 até 9, sendo que a variável n será o elemento de saída quando atingir 10.


Ct_Limite = 10;
n = 0;
while (n < Ct_Limite) {
 console.log(n);  
 n++;
}


Do...While


Este comando é uma variação do While, porém apresenta uma diferença sutil. Enquanto no While puro a condição tem que ser verdadeira, para iniciar a repetição, neste caso a condição é sempre feita ao menos uma vez a depender da lógica. No exemplo sera impresso 1 e ao entrar no loop imprimira o restante até o 9.


Ct_Limite = 10;
i = 0;
do {
i += 1;
console.log(i);
} while (i < Ct_Limite);


Label


Utilizei muito em Cobol, através do perform, quando passei as linguagens senti falta desta solução, até descobrir o label, ele funciona marcando uma determinada sessão do código e permitindo sua referencia. Exemplo


markLoop:
while (theMark == true) {
 facaAlgo();
}


For... in


Funciona de maneira parecida ao For explicado anterior, com uma nuance possibilita explorar o interior de arrays e objetos exibindo ou iterando com suas propriedades. Ficou confuso ne?


Veja o exemplo, talvez fique mais claro


let arr = [3, 5, 7];
arr.foo = "hello";
for (let i in arr) {
 console.log(i); // logs "0", "1", "2", "foo"
}


For... of


Estou dando no em sua cabeça? Vai piorar... este laço For, faz uma repetição dentro do objeto, array, ou seja, trazendo seu conteúdo para uso no programa.


Como assim??? Veja o exemplo vai te ajudar.


let arr = [3, 5, 7];
for (let i of arr) {
 console.log(i); // logs "3", "5", "7"
}


Viu não era tao difícil assim...


Apresentei todos os laços de repetição ate o momento, lembre-se que a ECMA Internacional poderá criar uma nova em algum novo release.


Fugindo dos loops


image


Mas antes de terminarmos, faltou comentar sobre dois super mega poderosos comandos .


Break


Este comando encerra o loop e executa o próximo comando fora do LOOP. Ai esta ficando bem confuso este troço? Calma, vamos por partes como diria o Jack, estripador. Quando o IF for verdadeiro a repetição FOR é encerrada.


for (i = 0; i < Ct_Limite; i++) {
if (a[i] == theValue) {
  break;
}
}


Continue


O Continue é primo o break, mas seu funcionamento é inverso do Break, quando numa repetição e encontrado o Continue, o ponteiro do programa retorna para o início do loop, refazendo todos os comandos. Eita piorou? Calma tem exemplo.


i = 0;
n = 0;
while (i < 5) {
i++;
if (i == 3) {
  continue;
}
 Console.log(i); // exibe 1, 2, 4, 5
}


Conclusão


Espero ter ajudado ao parça fazendo esta breve introdução aos loops (laços de repetição), fazendo um pequeno resumo e dando exemplos práticos, caso surja alguma duvida, não se acanhe, pergunte aqui ou no discord. Lembre-se juntos somos mais fortes.


Caso interesse entre em nosso coding dojo de Javascript e faça os exercícios para aprimorar seus conhecimentos.


Lembre codificar é uma arte de raciocínio artesanal, cada programa reflete a alma do programador, apresentando soluções impares para problemas do cotidiano. Treine, brinque, experimente, descubra um mundo totalmente inusitado.


Espero ter ajudado.


Convido a conhecerem meu Github: https://github.com/VagnerBellacosa


Acompanhe meus bootcamps : https://github.com/VagnerBellacosa/DIO_Bootcamps

 

Coding Dojo

🚀 Coding Dojo

https://web.dio.me/articles/coding-dojo


Saiba como participar do Desafio 21 Dias 21 Artigos


image


🚀 Como fazer o Desafio 21 dias 21 artigos ? @Desafio21DiasNaDIO


https://web.dio.me/articles/desafio-21-dias-21-artigos-desafio21diasnadio


🚀 Vencendo o Desafio 21 dias 21 artigos.


https://web.dio.me/articles/vencendo-o-desafio-21-dias-21-artigos

Espero ter ajudado ate o próximo artigo.


image



https://dio.me/articles/dia-4-javascript-e-lacos-de-repeticao


 Referência Bibliográfica


WIKIPEDIA - A Enciclopédia Livre, faça parte, ajude actualizando ou criando verbetes http://www.wikipedia.org


Google Books um repositório com milhões de livros digitalizados https://books.google.com/


Internet Archive, tudo aquilo que um dia foi publicado veio parar aqui. https://archive.org/


Biblioteca de ícones https://www.flaticon.com/



image


image Mais momento jabá, uma jornada na marginal Pinheiros com tare caótica e muito transito, outrora foi a praia dos paulistanos, famílias fazia pic nics em suas margens, banhistas nadavam e curtiam dias de folga, mas a cidade foi crescendo, avenidas foram construídas, a poluição correu solta e destruiu toda a natureza, tornando o Rio Tiete, aquele que permitiu conquistar o Brasil a Oeste de Tordesilhas, enfeou-se, embruteceu e tornou-se na triste imagem que vemos em nossos dias, muito triste, pesaroso assim, visite meu vídeo e veja para onde fui desta vez: https://www.youtube.com/watch?v=o1cX434YwQk


Bom curso a todos.


image https://www.linkedin.com/in/vagnerbellacosa/


image https://github.com/VagnerBellacosa/


Pode me dar uma ajudinha no YouTube?


image https://www.youtube.com/user/vagnerbellacosa


 #Desafio21DiasNaDIO 

Vagner Renato Bellacosa, IBM Champion e especialista em IBM Mainframe
IBM Z17 SYSTEM ONLINE
Sobre o autor

Vagner Renato Bellacosa

IBM Champion 2026 • Especialista em IBM Mainframe

Vagner Renato Bellacosa trabalha com IBM Mainframe desde 1988 , é IBM Champion e especialista em COBOL, CICS, Db2, z/OS e IBM Z. Compartilha experiências profissionais, conhecimento técnico, história da computação e práticas do universo mainframe para aproximar novas gerações das tecnologias que sustentam empresas, bancos e governos ao redor do mundo.

IBM Champion IBM Z COBOL CICS Db2 z/OS Mainframe desde 1988
GitHub LinkedIn
Inicializando conteúdo...