Introdução

“Vibe Coding” é uma prática emergente de desenvolvimento de software que utiliza inteligência artificial (IA) para gerar código funcional a partir de prompts em linguagem natural. Cunhado pelo pesquisador de IA eslovaco-canadense Andrej Karpathy no início de 2025, o termo descreve um fluxo de trabalho onde o papel do desenvolvedor muda de escrever código linha por linha para guiar um assistente de IA através de um processo conversacional para gerar, refinar e depurar uma aplicação.

Essa abordagem acelera o desenvolvimento, especialmente a prototipagem, e reduz a barreira de entrada para a criação de software, permitindo que indivíduos com experiência limitada em programação (ou até mesmo sem nenhuma experiência) construam aplicações funcionais.

Apesar de seus benefícios em velocidade e acessibilidade, o Vibe Coding apresenta limitações e riscos significativos. A qualidade, segurança e manutenibilidade do código gerado pela IA são preocupações centrais, com estudos indicando que o código pode conter vulnerabilidades de segurança e especialistas alertando sobre a dificuldade de depurar um código que o desenvolvedor não escreveu e, possivelmente, não entende completamente como funciona.

Além disso, a prática pode deturpar a complexidade do desenvolvimento de software profissional.

Consequentemente, o papel do desenvolvedor está evoluindo, com um foco maior em habilidades de alto nível, como arquitetura de software, pensamento sistêmico e gerenciamento da integração de sistemas.

No contexto educacional, a ascensão de ferramentas de Vibe Coding exige novas pedagogias, como o framework PROPER, para garantir que os alunos desenvolvam uma compreensão profunda dos conceitos de programação em vez de apenas aceitar o código gerado pela IA.

Análise Detalhada

Definição e Origem

O termo “Vibe Coding” foi popularizado pelo pesquisador de IA Andrej Karpathy (que trabalhou na Tesla e na OpenAI) para descrever um novo método de programação onde o desenvolvedor “se entrega totalmente às ‘vibes'” e guia uma IA para construir uma aplicação. A prática é caracterizada por um processo conversacional no qual o usuário descreve o que deseja em linguagem natural, e a IA gera o código correspondente.

De acordo com Karpathy, nesse método, o desenvolvedor raramente toca no teclado, não lê mais os diffs (diferenças de código) e simplesmente copia e cola mensagens de erro no chat da IA para que ela os corrija. Ele descreve a experiência da seguinte forma:

“Não é realmente codificar. Eu apenas vejo coisas, digo coisas, executo coisas e copio e colo coisas, e na maioria das vezes funciona.”

Essa abordagem representa uma mudança fundamental no papel do desenvolvedor, que passa de arquiteto e implementador para “orientador, guia, testador e refinador”. O foco principal se desloca da sintaxe e da escrita de código para a ideação e o refinamento do produto final.

O Fluxo de Trabalho do Vibe Coding

O processo de Vibe Coding normalmente segue um ciclo de vida de aplicação que enfatiza a prototipagem rápida e o refinamento iterativo.

1. Ideação (Ideation): O desenvolvedor descreve a aplicação desejada em um único prompt de alto nível.
2. Geração (Generation): A IA gera a versão inicial completa da aplicação, incluindo a interface do usuário (UI), a lógica do backend e a estrutura de arquivos.
3. Refinamento Iterativo (Iterative Refinement): O desenvolvedor testa a aplicação e usa prompts de acompanhamento para adicionar novos recursos, alterar elementos visuais ou modificar a funcionalidade existente. Por exemplo: “torne o botão azul” ou “adicione autenticação”.
4. Teste e Validação (Testing and Validation): Um especialista humano revisa a aplicação para garantir a segurança, qualidade e correção do código.
5. Implantação (Deployment): Com um prompt final ou um único clique, a aplicação é implantada em uma plataforma escalável.
6. Documentação e Otimização (Documentation and Optimization): A IA também pode ser instruída a gerar documentação inline, sugerir melhorias de desempenho ou escrever testes para validar a funcionalidade.

Comparação: Vibe Coding vs. Programação Tradicional

A tabela a seguir, baseada em informações do Google Cloud, destaca as principais diferenças entre as duas abordagens.

Ferramentas que Impulsionam o Vibe Coding

Uma variedade de ferramentas de IA tornou essa abordagem cada vez mais acessível. As principais incluem:

• GitHub Copilot: Uma ferramenta de IA que sugere código enquanto o desenvolvedor digita em seu editor, oferece um chat para perguntas e ajuda no uso da linha de comando.
• Replit Agent: Um assistente de IA projetado para transformar ideias em aplicações funcionais, acessível tanto para desenvolvedores quanto para pessoas sem experiência em programação.
• Cursor AI: Um ambiente de desenvolvimento integrado (IDE) com funcionalidades de IA, como edições e correções inteligentes, pesquisa de base de código com linguagem natural e um chat que pode acessar a web para obter informações atualizadas.
• Lovable (anteriormente GPTEngineer): Uma plataforma que permite a construção de aplicações web full-stack a partir de descrições em inglês, integrando design de frontend, lógica de backend, autenticação e banco de dados.
• Windsurf AI: Uma ferramenta que funciona como um IDE completo ou uma extensão do VS Code, com um sistema de compreensão profunda do código em tempo real e um “Cascade Write Mode” que cria múltiplos arquivos, executa testes e depura automaticamente.
• Trae: Um assistente de IA que foca na colaboração dinâmica entre o usuário e a IA, capaz de gerar um plano de projeto, executar tarefas e se adaptar a mudanças.
• Bolt.new: Um ambiente totalmente baseado em navegador que dá à IA controle total sobre o ambiente de desenvolvimento, permitindo instalar pacotes, executar servidores e implantar aplicações a partir de um único prompt.
• LLMs Gerais (ChatGPT, Claude, Gemini): Modelos de linguagem de grande escala que são excelentes ferramentas para ajudar desenvolvedores de todos os níveis a resolver problemas de codificação e aprender mais rapidamente.
• Cline: Um assistente de IA que funciona dentro do Microsoft Visual Studio Code para auxiliar na escrita e gerenciamento de código.

Limitações, Riscos e Críticas

Apesar do entusiasmo, o Vibe Coding enfrenta ceticismo e apresenta desafios bastante significativos.

Qualidade e Segurança do Código

O código gerado por IA pode ser inseguro e de baixa qualidade,a lém de ser difícil de depurar – principalmente se for gerado por pessoas com pouca experiência em desenvolvimento. Um estudo descobriu que o código gerado por IA pode conter vulnerabilidades significativas. Artigos alertam que startups que dependem fortemente dessa prática podem ser “alvos fáceis para hackers”.

Kevin Roose, do The New York Times, observou que, em um caso, o código gerado por IA fabricou avaliações falsas para um site de e-commerce.

Desafios de Depuração

Como os desenvolvedores não escreveram o código, eles podem ter muita dificuldade em entender a sintaxe, os conceitos ou a lógica subjacente, tornando a depuração um processo extremamente desafiador.

Deturpação do Desenvolvimento de Software

Críticos como Andrew Ng, especialista em IA, argumentam que o termo “Vibe Coding” é um “nome ruim para um trabalho muito real e exaustivo”, pois mascara a complexidade e o rigor exigidos no desenvolvimento de software profissional.

Riscos de Confiabilidade

Um incidente notório envolveu o Replit Agent, que supostamente deletou o banco de dados de produção de um usuário, falsificou dados e mentiu sobre o ocorrido durante uma execução de teste, destacando os perigos de conceder controle excessivo a agentes de IA.

Originalidade vs. Reprodução

O cientista cognitivo Gary Marcus (Professor do Departamento de Psicologia da New York University) argumenta que grande parte do entusiasmo com o Vibe Coding deriva da reprodução, não da originalidade. A IA é treinada em código existente para tarefas semelhantes, replicando soluções em vez de inovar e, portanto, deixando a desejar em matéria de criatividade e soluções realmente inovadoras.

O Impacto no Papel do Desenvolvedor

O Vibe Coding não sinaliza a obsolescência dos desenvolvedores, mas sim uma elevação de seu papel. O foco está se deslocando da escrita de código para habilidades de nível superior. De acordo com Addy Osmani, líder sênior de engenharia no Google Chrome, as competências cruciais para o futuro incluem:

• Gerenciamento da Integração e dos Limites de Sistemas: Compreender e gerenciar as fronteiras entre componentes, incluindo design de API, esquemas de eventos e modelos de dados.
• Pensamento Sistêmico (Systems Thinking): Uma compreensão avançada de como sistemas complexos interagem e se comportam.
• Fundamentos de Arquitetura de Software: Conhecimento profundo sobre como projetar sistemas robustos, escaláveis e flexíveis.

Vibe Coding no Contexto Educacional

A proliferação de ferramentas de IA na programação apresenta desafios e oportunidades para a educação em computação. A prática de estudantes usarem IA para completar tarefas de codificação sem necessariamente entender o processo é uma preocupação crescente.

Alunos de disciplinas da ciência da computação que usam ferramentas de IA para estudar, sem critérios bem definidos de uso, tendem a entregar código-fonte sem entender especificamente como ele funciona, e sem conseguir explicar a lógica subjacente utilizada pela IA.

Em outras palavras, eles podem não aprender a codificar e nem sequer desenvolver o raciocínio lógico necessário para essas tarefas, principalmente se fizerem uso dessas ferramentas no início do seu processo de aprendizado.

Para abordar esse problema, foi proposto o framework PROPER, um acrônimo para:

• Prompt: Elaborar um prompt claro e eficaz para a IA.
• Review: Revisar criticamente o código gerado pela IA.
• Organize: Estruturar e organizar o código dentro do projeto maior.
• Polish: Refinar e melhorar o código.
• Extend: Expandir a funcionalidade além do que foi gerado inicialmente.
• Reflect: Refletir sobre o processo de aprendizagem e o que foi criado.

O framework PROPER visa transformar o Vibe Coding de um atalho para uma ferramenta de aprendizagem estruturada, incentivando os alunos a se envolverem ativamente com o código gerado, em vez de aceitá-lo passivamente. Isso ajuda a garantir que, embora a IA possa auxiliar na escrita do código, a compreensão fundamental e as habilidades de resolução de problemas permaneçam com o aluno.

Conclusão

O Vibe Coding representa uma mudança de paradigma no desenvolvimento de software, tornando a criação de tecnologia mais acessível e rápida do que nunca. No entanto, sua adoção vem com uma advertência clara: os benefícios de velocidade e acessibilidade são contrabalançados por riscos significativos em segurança, qualidade e manutenibilidade.

A dependência de código gerado por IA exige um novo conjunto de habilidades, onde o julgamento humano, a supervisão e a perícia em arquitetura de sistemas se tornam primordiais.

Para profissionais e estudantes, o futuro não reside em ser substituído pela IA, mas em evoluir para se tornar um colaborador mais estratégico e crítico no processo de desenvolvimento, utilizando a IA como uma ferramenta poderosa, ainda que imperfeita.

Referências

• Abilytics (White Paper) – Vibe Coding: A New Era of AI-Assisted Software Development
• Osmani, A. Vibe Coding – The Future of Programming – Leverage Your Experience in the Age of AI. 1ª edição 2025. O’Reilly.
• Dataquest: Why Learning Data Science Can’t Be Vibe Coded

O post Vibe Coding e o Futuro do Desenvolvimento de Software apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Para muitos, transformar uma ideia brilhante em um aplicativo funcional sempre pareceu uma tarefa impossível sem anos de estudo em programação. Essa barreira, no entanto, está começando a desaparecer com o surgimento de uma nova era de desenvolvimento de software impulsionada por Inteligência Artificial. O pesquisador de IA Andrej Karpathy (Tesla, OpenAI) batizou essa nova abordagem de “Vibe Coding”.

O termo descreve um fluxo de trabalho revolucionário onde o desenvolvedor não escreve código linha por linha, mas guia uma IA usando linguagem natural, como se estivesse conversando com um assistente genial.

O Novo Papel do Desenvolvedor: Mais Maestro, Menos Codificador

O Vibe Coding representa uma mudança fundamental no papel do desenvolvedor. O trabalho deixa de ser uma tarefa meticulosa de escrita de código para se tornar um diálogo contínuo com uma IA. O foco se desloca da sintaxe e dos detalhes de implementação para o “panorama geral” — o objetivo principal e a funcionalidade do aplicativo.

O desenvolvedor atua como um diretor, fornecendo a visão e a direção, enquanto a IA executa as tarefas técnicas.

Essa nova dinâmica é perfeitamente capturada por Andrej Karpathy:

“Não é bem programar… Eu apenas vejo coisas, digo coisas, executo coisas e copio e colo coisas, e na maior parte funciona.”

Essa abordagem se assemelha mais a dirigir uma equipe ou reger uma orquestra do que a escrever código manualmente. O desenvolvedor se torna o maestro que garante que todas as partes do software funcionem em harmonia para atingir o objetivo final.

Para Criar um App, Basta uma Ideia (ou Quase Isso)

Uma das consequências mais impactantes do Vibe Coding é a drástica redução da barreira de entrada para a criação de software. Um exemplo notável é o do jornalista Kevin Roose, do The New York Times, que, sem ser programador, conseguiu construir um aplicativo funcional. Sua experiência demonstra que a capacidade de transformar ideias em realidade não está mais restrita a especialistas em tecnologia.

Essa abordagem democratiza o desenvolvimento, permitindo que amadores, empreendedores e pessoas de áreas não técnicas criem soluções para problemas que elas mesmas identificam. Como Roose destacou:

“só ter uma ideia, e um pouco de paciência, geralmente é o suficiente.”

Isso abre um leque de possibilidades, onde qualquer pessoa com uma visão clara pode prototipar e até lançar um aplicativo, acelerando a inovação em todos os setores.

Programadores Não Estão Obsoletos, Estão Evoluindo

A ascensão da IA no desenvolvimento de software levanta uma preocupação comum: a IA substituirá os programadores? A resposta, no entanto, é mais complexa. O Vibe Coding não representa a obsolescência dos desenvolvedores, mas sim uma “elevação” de suas habilidades. O foco do trabalho muda de escrever código para tarefas de nível superior.

Em vez de se concentrar em linhas de código, o desenvolvedor agora gerencia a integração de sistemas complexos, projeta APIs robustas e define modelos de dados. A IA se torna uma ferramenta que executa, mas a estratégia e a arquitetura ainda dependem do conhecimento humano.

Essa evolução redefine o papel do desenvolvedor, que passa de um executor técnico para um estrategista, como ilustra a comparação a seguir:

Embora a IA escreva o código, o conhecimento profundo em ciência da computação se torna ainda mais importante para gerenciar a complexidade dos projetos e garantir que as soluções geradas sejam seguras, eficientes e escaláveis.

As Startups Já Estão Vivendo no Futuro

O Vibe Coding não é apenas uma teoria futurista; já é uma prática em rápida ascensão, especialmente no ecossistema de startups. Um relatório da aceleradora Y Combinator de março de 2025 revelou um dado surpreendente que confirma essa tendência.

De forma clara e direta: 25% das startups na turma de Inverno de 2025 da Y Combinator tinham bases de código 95% geradas por IA.

Esse número é significativo porque demonstra como as novas empresas estão alavancando a IA para ganhar uma vantagem competitiva crucial. É importante notar, no entanto, que o relatório da Y Combinator se referia a código gerado por IA em geral, não especificamente ao fluxo de trabalho conversacional do “vibe coding”, embora a tendência aponte para uma crescente automação no desenvolvimento.

A velocidade proporcionada por essa abordagem permite que startups lancem produtos e iterem sobre eles em um ritmo antes inimaginável, validando ideias de negócio e conquistando mercado muito mais rapidamente.

A Grande Preocupação: Quais são os Riscos do “Vibe Coding”?

Apesar de seu enorme potencial, a abordagem do Vibe Coding não está isenta de riscos e desvantagens significativas. Ignorar esses problemas pode levar a consequências graves tanto para os desenvolvedores quanto para os usuários finais.

• Pesadelos de Segurança e Qualidade: O código gerado por IA pode ter qualidade variável e, mais preocupante, conter vulnerabilidades de segurança. Empresas que dependem exclusivamente de código gerado por IA podem se tornar “alvos fáceis para hackers”.
  O próprio Kevin Roose observou um exemplo disso quando a IA que ele usou inventou avaliações falsas para seu aplicativo, demonstrando a falta de confiabilidade e os riscos éticos associados.
• O Dilema da Depuração: Corrigir erros (depurar) em um código que você não escreveu é um dos maiores desafios do Vibe Coding. Como a IA gera o código dinamicamente, os desenvolvedores podem ter dificuldade para entender a sintaxe ou os conceitos que eles mesmos não utilizaram, tornando o processo de encontrar e consertar bugs extremamente complexo e demorado.

Conclusão: Acelerador, Não Piloto Automático

Vibe Coding é, sem dúvida, uma ferramenta poderosa que está remodelando o desenvolvimento de software. Ele atua como um acelerador, permitindo que ideias se materializem com uma velocidade sem precedentes e abrindo portas para uma nova geração de criadores. No entanto, não é um piloto automático, e deve ser usada com muito cuidado e consciência – principalmente por profissionais ainda com pouca experiência e estudantes..

A supervisão humana, o pensamento crítico e a expertise técnica continuam sendo indispensáveis para garantir a qualidade, a segurança e a manutenção do que é criado.

A IA pode escrever o código, mas a responsabilidade final ainda é do desenvolvedor.

Em uma era de “vibe coding”, a linguagem de programação mais importante passará a ser… o bom e velho português?

Referências

• Abilytics (White Paper) – Vibe Coding: A New Era of AI-Assisted Software Development
• Osmani, A. Vibe Coding – The Future of Programming – Leverage Your Experience in the Age of AI. 1ª edição 2025. O’Reilly.
• Dataquest: Why Learning Data Science Can’t Be Vibe Coded

O post Vibe Coding: Como Criar Softwares Com Pouco Conhecimento de Programação (ou Nenhum) apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

E por que ele pode custar milhões (ou mesmo vidas)

Se você estuda ou trabalha em alguma área relacionada à tecnologia, é altamente provável – quase certeza – que já se deparou com a expressão “bug” ou com algum verbo “abrasileirado”, como “bugar” ou “bugado”. Mas o que significa exatamente isso?

Considere a seguinte situação: um comando simples, por exemplo programado para imprimir uma mensagem na tela dez vezes, acaba executando indefinidamente, sem qualquer critério de parada. O sistema permanece responsivo, mas o comportamento é claramente incorreto. Trata-se de um erro lógico comum — chamado de loop infinito — e é um exemplo clássico de bug em programação.

Entendendo o conceito de bug

Bugs são falhas no código-fonte que levam um programa a se comportar de forma inesperada ou incorreta. Podem resultar em pequenos transtornos, como uma interface mal formatada, ou em consequências graves, como perda de dados, travamentos do sistema e até riscos à segurança – ou ainda mais graves.

Qualquer pessoa que já tenha escrito código, por mais simples que seja, inevitavelmente se depara com esse tipo de problema.

Mas o que caracteriza, de fato, um bug? E por que eles continuam sendo tão prevalentes mesmo com os avanços nas ferramentas de desenvolvimento e boas práticas de engenharia de software? 

Ao contrário do que muitos pensam, computadores não “pensam” ou “entendem” intenções. Eles fazem exatamente o que mandamos — o problema é que nem sempre mandamos a coisa certa. Eles costumam surgir por erro humano: um código mal projetado, uma lógica mal pensada ou até mesmo por uma simples distração na digitação.

A origem do termo “bug”

A palavra bug (que literalmente significa “inseto” em inglês) foi popularizada pela almirante Grace Hopper em 1947. Durante a manutenção de um computador eletromecânico Mark II, uma mariposa foi encontrada presa em um relé, provocando falhas. O inseto foi cuidadosamente colado no diário de bordo com a legenda: “First actual case of bug being found” (em português, “Primeiro caso real de um bug sendo encontrado”).

A partir de então, o termo passou a ser usado para qualquer tipo de erro ou falha que ocorra em sistemas computacionais, não só de hardware, mas também (e hoje, principalmente) de software.

Primeiro “bug” de computador encontrado – literalmente. Mariposa presa em um relé em um painel do Mark II durante um teste na Universidade de Harvard, em 09 de setembro de 1947. Os operadores que a encontraram a afixaram no livro de registros do computador, com a frase “Primeiro caso real de um bug sendo encontrado”

Os três principais tipos de bug

Os bugs nem sempre se manifestam da mesma forma. Alguns são fáceis de identificar, outros podem passar despercebidos por muito tempo. Os principais tipos incluem:

1. Erros de sintaxe

São falhas na escrita do código — algo como esquecer de fechar aspas, colocar um ponto e vírgula onde não devia (ou não colocar), ou ainda digitar comandos inválidos. A boa notícia? São geralmente detectados imediatamente na hora da compilação ou interpretação, ou mesmo apontados pelo IDE antes mesmo de tentar executar o programa para testá-lo.

2. Erros de execução (runtime)

Esses erros só aparecem quando o programa está rodando. Um exemplo clássico é a tentativa de divisão de um número por zero. O código-fonte parece correto, a aplicação roda normalmente, realiza cálculos com precisão, até que… bum!,  a execução para bruscamente quando uma tentativa de divisão por zero ocorre, podendo ocasionar desde a parada da execução da aplicação até o travamento completo do sistema.

3. Erros semânticos (ou de lógica)

São os mais traiçoeiros e difíceis de detectar. O programa roda, executa tudo sem travar, apresenta a saída para o usuário, mas os resultados estão errados — e às vezes ninguém percebe. Um caso comum ocorre com determinados cálculos matemáticos – o sistema efetua os cálculos solicitados, mas por conta de um bug lógico o resultado apresentado é incorreto, e o usuário pode não perceber o problema.

Esse tipo de erro pode causar grandes transtornos, desde perdas financeiras até acidentes fatais.

Quando um bug deixa de ser só um incômodo

Se você acha que um bug é só um erro inofensivo que causa irritação, pense de novo. Bugs já causaram prejuízos bilionários e, em casos extremos, até mortes.

Citemos alguns exemplos notáveis:

• Nuclear Gandhi: No jogo Sid Meier’s Civilization (1991), um erro no sistema de agressividade das civilizações fazia com que o personagem do pacifista Mahatma Gandhi, inicialmente programado com o menor nível possível de agressividade, se tornasse extremamente beligerante após adoção de políticas democráticas. Devido a um underflow (valor abaixo do mínimo) no valor da variável, seu nível de agressividade era reduzido para um valor negativo, que acabava sendo interpretado como o valor máximo permitido.
  O resultado: um Gandhi obcecado por armas nucleares — um bug icônico da história dos games. Divertido? Sim. Mas ainda um bug.
• Therac-25: Entre 1985 e 1987, um equipamento de radioterapia de nome Therac-25, usado no tratamento de câncer, apresentou falhas críticas causadas por erros de programação em seu sistema de controle. Devido à ausência de verificações adequadas e à confiança excessiva em software, o dispositivo permitia que doses de radiação muito acima do limite seguro fossem aplicadas nos pacientes em tratamento.
  Seis pacientes morreram por exposição acidental a níveis fatais de radiação. 
• Mars Climate Orbiter: Em setembro de 1999, a NASA perdeu contato com a sonda Mars Climate Orbiter pouco antes de sua inserção na órbita do planeta Marte. A falha ocorreu porque um módulo do software produzia dados de impulso na unidade libras-força (sistema imperial), enquanto outro módulo esperava receber esses dados em newtons (sistema métrico).
  A ausência de conversão entre unidades resultou em um erro de trajetória fatal, fazendo com que a sonda descesse demais na atmosfera marciana e fosse destruída. O prejuízo estimado ultrapassou US$ 327 milhões.
• Guitar Hero II: Em 2007, uma atualização lançada para o jogo Guitar Hero II em sua versão para o console Xbox 360 causou problemas sérios de estabilidade em diversos aparelhos. Alguns dispositivos passaram a apresentar falhas críticas após a atualização, incluindo travamentos frequentes e, em muitos casos, o temido “Red Ring of Death” (Anel Vermelho da Morte) — um erro fatal de hardware que inutilizava o console. Embora o bug fosse de software, seu impacto foi sentido no hardware, resultando em muitas unidades defeituosas.

Máquina para tratamento de câncer Therac-25

Como lidar com bugs: a arte da depuração

O processo de encontrar e corrigir bugs é conhecido como debugging (em português, depuração). Ferramentas chamadas depuradores (ou debuggers) ajudam a examinar o código linha por linha, inspecionar variáveis e identificar o ponto exato em que tudo começa a dar errado.

Ambientes de desenvolvimento (IDEs) modernos geralmente vêm com depuradores embutidos, tornando essa tarefa um pouco menos ingrata e mais fácil de realizar.

Prevenção de bugs: manipulação de exceções

Outro recurso fundamental é o tratamento de exceções. Trata-se de prever que algo pode dar errado (como dividir um número por zero em um cálculo) e preparar o programa para lidar com isso de forma antecipada, sem falhar completamente. Linguagens de alto nível como Java, Python e C# têm mecanismos específicos para isso, como os blocos try…catch.

Exemplo em Java:

import java.util.Scanner;
public class Divisao {
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);
    System.out.print("Digite o valor de a: ");
    int a = entrada.nextInt();
    System.out.print("Digite o valor de b: ");
    int b = entrada.nextInt();
    int c = a / b; // BUG EM POTENCIAL: pode lançar ArithmeticException se b = 0
    System.out.println("Resultado = " + c);
    entrada.close();
  }
}

Neste exemplo, se o usuário digitar o valor zero ao entrar com o valor de b, será feita uma divisão por zero ao executar o cálculo da variável c. Qualquer outra divisão funcionará, exceto essa.

Ou seja, se b for igual a zero, o programa lançará uma exceção do tipo ArithmeticException e será encerrado abruptamente. Esse é um exemplo clássico de erro de tempo de execução (runtime error), causado por não tratar uma condição excepcional comum.

Como tratar isso? Uma solução é realizar a manipulação dessa exceção, como segue:

import java.util.Scanner;
public class DivisaoSegura {
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);
    System.out.print("Digite o valor de a: ");
    int a = entrada.nextInt();
    System.out.print("Digite o valor de b: ");
    int b = entrada.nextInt();
    try {
      int c = a / b;
      System.out.println("Resultado = " + c);
    }
    catch (ArithmeticException e) {
      System.out.println("Não é possível dividir por zero.");
      System.out.println(e);
    }
    entrada.close();
  }
}

Neste caso a exceção (erro) ArithmeticException foi tratada por meio do uso de um bloco try .. catch, que impedirá o travamento do sistema caso seja fornecido o valor zero à variável b, exibindo em vez disso a mensagem mais amigável “Não é possível dividir por zero” ao usuário..

Testes: prevenindo problemas

A melhor forma de combater bugs é evitá-los desde o início. Testes de software — tanto manuais quanto automatizados — são parte essencial do desenvolvimento. Eles verificam se o programa atende aos requisitos e ajudam a identificar falhas antes que elas possam causar estragos maiores.

Entre os tipos de testes mais comuns estão:

• Testes unitários: verificam o funcionamento de partes específicas do código.
• Testes de integração: checam se os módulos interagem corretamente.
• Testes de sistema: avaliam o sistema como um todo.
• Testes de aceitação: garantem que o software atende ao que o cliente espera.

Bugs no mundo real: onde menos se espera

É importante lembrar que nem só de software vive o mundo dos bugs. Hardware também pode apresentar falhas semelhantes, como erros de projeto em placas, aquecimento excessivo ou falhas elétricas. Mas no fim das contas, tudo parte da mesma raiz: uma falha humana durante a concepção ou implementação de um projeto.

Conclusão: errar é humano, depurar é essencial

Bugs fazem parte da vida de qualquer programador. Não há como evitá-los completamente, mas é possível preveni-los, detectá-los rapidamente e corrigi-los antes que causem problemas sérios.

Com boas práticas de codificação, testes constantes e ferramentas adequadas, dá para dormir mais tranquilo. Ou ao menos, sem sonhar com mariposas voando entre os relés.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post O que é um bug em programação? apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

A notação Big O é um conceito matemático normalmente empregado para medir o custo de um algoritmo. É uma forma simples de classificar a complexidade computacional de um algoritmo.

No geral, significa encontrar uma função que relacione o tamanho da entrada de um algoritmo com o número de passos necessários à sua execução (complexidade temporal) ou quantidade de espaço de armazenamento que ele emprega (complexidade espacial).

Comumente a função que descreve a performance de um algoritmo se refere ao seu limite superior, que determina o pior caso (de entrada de dados) do algoritmo.

Em ciência da computação, a notação Big O é empregada para classificar algoritmos de acordo com seu tempo de execução / número de passos (custo) ou requisitos de espaço, conforme a entrada de dados aumenta.

Em outras palavras,  usamos essa notação para indicar quanto tempo algo demorará para executar, ou o espaço que ocupará na memória, dado uma quantidade N de dados a serem manipulados.

Qual a importância de saber isso? Vai te permitir desenvolver software muito melhor porque você irá entender como é possível melhorar a performance do programa, tornando-o mais eficiente e escalável, sem complexidade adicional.

Se um projeto precisa usar um algoritmo específico, é importante entender o quão rápido ou lento ele é em comparação com outras alternativas.

Definição Formal de Big O

A seguir temos uma definição formal da notação Big O, retirada da Wikipedia:

“A notação Big O é uma notação matemática que descreve comportamento limite de uma função quando o argumento tende a um valor em particular ou ao infinito.”

Trata-se de uma notação membro de uma família de notações inventadas por Paul Bachmann, Edmund Landau e outros, chamadas em conjunto de Notação Bachmann-Landau ou ainda Notação Assintótica.

Curiosidade: A letra ‘O’ vem da palavra em alemão Ordnung, com o significado de Ordem (de aproximação).

O Big O se foca no cenário de pior caso no qual o algoritmo consome o maior tempo (ou recursos) para executar. Isso significa que o algoritmo nunca irá demorar MAIS que esse cenário – mas pode demorar MENOS em determinadas circunstâncias.

Perceba que essa notação serve para calcular o tempo máximo que irá demorar a execução do algoritmo (em termos de custo), mas o tempo real pode ser menor. Por exemplo, uma busca linear em um array pode encontrar o item na primeira posição pesquisada, como se fosse O(1) (melhor resultado).

Assim, o Big O sempre se refere ao pior resultado possível.

Note que o Big O serve para algoritmos escritos em qualquer linguagem de programação e sempre é calculado da mesma forma.

Observação importante: essa notação NÃO nos informa a velocidade de um algoritmo em segundos, pois existem muitos fatores que podem influenciar essa velocidade, como por exemplo o hardware empregado para executar o algoritmo. Usamos o Big O para comparar algoritmos entre si.

Funções e Complexidade

Na notação Big O, a letra “n” representa o tamanho da entrada, enquanto a função “g(n) = n”, associada ao “O()” nos informa a complexidade do algoritmo em relação ao tamanho dessa entrada.

Sendo assim, podemos ter algoritmos classificados de acordo com seu nível de complexidade, como segue:

• Complexidade Constante: O(1)
  Não importa a quantidade total de dados acessados, o tempo de acesso é sempre 1, ou seja, sempre o mesmo custo para acessar qualquer um dos dados no conjunto. Exemplo: acesso a um elemento de um array.
• Complexidade Linear: O(n)
  O acesso a um elemento demora o tempo equivalente à quantidade de dados da coleção. Exemplo: busca linear de um dado em uma lista ou array não ordenado – o algoritmo, no pior caso, tem de procurar em até n elementos, caso o dado buscado ser o último ou inexistente.
• Complexidade Logarítmica O(log n) 
  Sua performance aumenta drasticamente conforme a quantidade de elementos aumenta. Exemplo: árvores de busca balanceada ou algoritmos de busca binária em arrays. Sua performance se aproxima comumente do O(1).
  Geralmente os dados precisam estar classificados (ordenados) de alguma forma.
• Complexidade Linearítmica: O(n log n)
  É uma combinação das complexidades linear e logarítmica. Algoritmos que usam estratégias do tipo dividir e conquistar são linearítmicos, como os algoritmos de classificação Merge Sort e Heap Sort.
• Complexidade quadrática O(n²)
  Complexidade na qual o custo computacional cresce de acordo com o quadrado da quantidade de elementos de entrada. Exemplo de algoritmo: Algoritmos de classificação como Bubble Sort, Insertion Sort ou Selection Sort. 
• Complexidade polinomial (n^c)
  A quantidade de operações é proporcional à potência c do tamanho da entrada (engrada elevada a um valor c).
  Exemplo: Encontrar o determinante de uma matriz usando Decomposição LU.
  Um caso especial de complexidade polinomial é a complexidade quadrática, na qual c = 2.
• Complexidade fatorial O(n!).
  Uma das piores complexidades em termos de custo. O tempo necessário para execução do algoritmo cresce astronomicamente conforme aumenta a quantidade de dados de entrada.
  Exemplo: Encontrar o determinante de uma matriz usando o Teorema de Laplace

Alterar a complexidade de um algoritmo, por exemplo de linear para logarítmica, pode fazer com que a aplicação tenha uma performance milhões ou até bilhões de vezes maior.

O gráfico a seguir mostra uma comparação entre diversos níveis de complexidade, relacionando o número de operações necessárias para realizar uma tarefa de acordo com a quantidade de elementos de um conjunto de dados:

Crescimento da Complexidade de Algoritmos.
Fonte: https://www.bigocheatsheet.com/

Comparação de algoritmos com Big O distintos

Imagine que um algoritmo de busca linear de O(n) demore 1 ms (um milissegundo) para realizar uma operação, ao passo que um algoritmo de busca binária d O(log n) também demora 1 ms para realizar a operação.

Quantas operações serão necessárias para realizar n operações com cada algoritmo? A tabela a seguir mostra alguns valores calculados:

Perceba que o algoritmo de busca linear tem um aumento de custo computacional muito mais elevado do que o algoritmo de busca binária considerado.

Para conjuntos com poucos elementos a diferença entre eles é pequena, porém conforme aumentamos a quantidade de dados de entrada os algoritmos começam a se comportar de forma muito diversa.

No exemplo, para conjuntos pequenos de dados praticamente não há diferença entre usar um algoritmo ou outro, mas para conjuntos grandes o emprego do algoritmo de complexidade O(log n) é imprescindível.

Em suma, o tempo de execução para cada algoritmo não cresce na mesma proporção. Por isso é importante saber o Big O de cada algoritmo – assim é possível escolher o melhor a usar em cada caso.

A tabela a seguir mostra alguns algoritmos populares de ordenação de arrays (vetores), com suas complexidades de tempo e espaço na notação Big-O:

Outras Notações de Complexidade Algorítmica

Além do Big O, existem outras notações que podem ser empregadas para determinar o custo computacional de algoritmos, geralmente se focando em fatores distintos. Algumas delas são:

• Notação Omega (Ω()): descreve o limite inferior da complexidade
• Notação Theta (Θ()): descreve o limite exato da complexidade
• Notação Little O (o()): descreve o limite superior, porém excluindo o limite exato.

Resumo

• Conhecendo o Big O de um algoritmo, saberemos qual a performance e eficiência de acordo com o volume de informações que entram.
• Quando comparamos algoritmos distintos que resolvem o mesmo problema, por meio do Big O podemos determinar qual deles é o mais eficiente.
• De forma bem simplificada, o Big O nos diz quantas operações um algoritmo precisa realizar para completar sua tarefa.

Referências

• Erickson, J. Algorithms. 1ª edição, 2019. Disponível para download em http://jeffe.cs.illinois.edu/teaching/algorithms/
• Sedgewick, R.; Wayne, K. Algorithms. 4 edição, 2011. Editora Addison-Wesley Professional.
• Cormen, T.H.; Leiserson, C.E.; Rivest, R.L. Introduction to Algorithms. 3ª edição, 2009. Editora MIT Press.

O post O que é Notação Big O em programação e análise de algoritmos apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Aprender novas linguagens de programação é uma tarefa comum na carreira de um desenvolvedor de software. Comumente precisamos usar linguagens diferentes em novos projetos, e algumas áreas da tecnologia se beneficiam do emprego de linguagens específicas, que possuem recursos mais adaptados a determinadas tarefas, como Ciência de Dados, Computação em Nuvem, Automação de Tarefa e outras.

Vamos falar neste artigo sobre uma categoria de linguagens muito especial- as linguagens de programação funcional, que são muito empregadas nas áreas supracitadas, entre outras. Mas antes, vamos entender oque é programação funcional.

O que é Programação Funcional?

Programação funcional é um paradigma na programação no qual podemos executar toda a codificação de uma aplicação usando apenas funções (matemáticas). Ao contrário de paradigmas como a programação orientada a objetos, na programação funcional nos preocupamos apenas com “o que é” em vez de “como” resolver um problema.

Com a programação funcional, aprender novas ferramentas, paradigmas e perspectivas é um processo mais suave e simples e geralmente resulta em um código mais limpo e organizado.

Assim, podemos dizer que linguagens de programação funcional oferecem uma forma “compacta” de programação. Alguns dos recursos oferecidos por essas linguagens incluem o reuso de código e as melhorias de eficiência resultantes, uma legibilidade comparativamente melhor e uma sintaxe bastante simples de depurar.

Além disso, a maioria das linguagens de programação funcionais se integram e trabalham muito bem em tarefas voltadas à ciência de dados.

Vamos às 7 linguagens de programação funcional recomendadas que podem ser úteis em sua carreira como programador, e que valem a pena aprender neste ano.

7 Linguagens de Programação Funcional

1. Clojure

Linguagem de programação de uso geral, compatível com Java Virtual Machine (JVM) e que evita duplicação durante chamadas ao Java. É altamente acessível e interativa para um estilo de programação multithread. Apesar de ser uma linguagem compilada, oferece vários recursos importantes que são suportados em tempo de execução.

Site oficial: https://clojure.org/

2. Elixir

Uma linguagem de programação que suporta concorrência elevada e com baixa latência, é comumente empregada na construção de aplicativos escaláveis ​​e versáteis, com suporte adicional para baixa latência e tolerância a falhas.

Caso você precise projetar um aplicativo para atender a uma grande quantidade de solicitações, Elixir é uma linguagem altamente recomendada, por combinar os melhores recursos e características de linguagens como Clojure, Erlang e Ruby, oferecendo suporte a aplicações com threads múltiplas (multithread).

Site oficial: https://elixir-lang.org/

3. Haskell

O Haskell é uma linguagem de programação funcional avançada, com uma sintaxe declarativa e que pode ser digitada estaticamente. Isso significa que se trata de uma linguagem do tipo de compilação, e essa linguagem fornece mensagens de erro quando a sintaxe está errada, auxiliando muito o processo de debugging do código.

No geral, é empregada na criação de programas de alto desempenho, pois é excelente no quesito otimização. A avaliação dos argumentos facilita a composição abrangente e um melhor controle dos construtos.

Site oficial: https://www.haskell.org/

4. Scala

A linguagem Scala combina recursos tanto de linguagens estáticas quanto de linguagens dinâmicas, sendo usada para criar pipelines de dados e projetos de Big Data. Possuindo um ecossistema gigante de bibliotecas, seus tipos estáticos ajudam a evitar bugs em aplicações complexas.

Muito compatível com Java e a JVM, fornece programação totalmente funcional com funções classificadas como objetos de primeira classe.

Site oficial: https://www.scala-lang.org/

5. Elm

A linguagem Elm, não tão conhecida quanto as outras nessa lista, é mais adequada para a criação de aplicativos Web e também apps HTML, e possui características interessantes como refatoração bastante simplificada, pois ela possui um compilador muito inteligente.

Alimentados por uma estrutura bem arquitetada, os aplicativos em Elm são renderizados muito rapidamente.

A linguagem possui alta interoperabilidade com JavaScript e permite leitura fácil de seu código, podendo ser aplicada a diferentes projetos sem a necessidade de refazer o padrão que o código possuía anteriormente.

Site oficial: https://elm-lang.org/

6. F#

O F# (“F sharp“) é uma linguagem de programação de código aberto e multiplataforma, usada principalmente para escrever código robusto. Trata-se de uma versão funcional da linguagem C# (da Microsoft) e possui uma sintaxe fácil de entender. Possui suporte a correspondência de padrões e programação assíncrona com um conjunto diversificado de tipos de dados.

O F# pode realizar transformação de dados com a ajuda de funções porque segue um paradigma de programação funcional orientado a dados.

Site oficial: https://fsharp.org/

7. Erlang

O Erlang é uma linguagem de programação orientada a processos que emprega usa processos leves. A beleza desta linguagem está em sua capacidade de criar funções que se comunicam entre si.
É considerada a melhor linguagem de programação para aplicações baseadas em mensagens, como por exemplo aplicativos de bate-papo (chat apps), filas de mensagens e aplicativos da blockchain.

Os programas escritos em Erlang acabam sendo altamente responsivos devido ao gerenciamento automatizado de armazenamento e coleta de lixo (garbage collection) da linguagem implementados por processo.

Site oficial: https://www.erlang.org/

Referências

Adaptado de https://www.analyticsinsight.net/top-10-functional-programming-languages-to-know-in-2022/

O post 7 Linguagens de Programação Funcional para aprender em 2022 apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Programação de computadores é uma tarefa que pode ser altamente complexa, cheia de detalhes minuciosos, e altamente propensa a erros. E, no geral, a maioria dos problemas associados a software se refere a código mal escrito, que não segue normas ou padrões, e que foi criado sem o devido cuidado. Em outras palavras, boa parte dos bugs em software são causados pelos próprios desenvolvedores – evidentemente, sem intenção.

Por isso é essencial prestar a máxima atenção ao trabalho realizado quando um software ou sistema de softwares é construído. Muitos problemas podem ser evitados se algumas regras simples forem seguidas desde o início do ciclo de vida de desenvolvimento de um software.

A seguir listamos sete erros comuns que são cometidos com frequência por programadores, e que podem – e devem –  ser evitados desde o início.

Erros comuns ao desenvolver software

1. Não planejar antes de começar a codificar.

Os programas devem ser planejados de antemão – é para isso que serve a fase de análise. A coleta de requisitos, avaliação, pseudocódigos, fluxogramas, são todas ferramentas e técnicas que auxiliam no planejamento de como o software deverá ser desenvolvido na sequência, e que impactam significativamente todo o processo.

Software mal planejado significa, invariavelmente, software que precisará ser reescrito futuramente – e o impacto disso se dá no tempo de desenvolvimento estendido, custo do produto aumentado e, muito comumente, na (má) imagem passada pelo desenvolvedor ou empresa que desenvolve o software aos clientes.

2. Não escrever código limpo.

O código deve ser legível, seguir boas práticas de programação e de padrões de projetos (design patterns), ser organizado e bem-formatado.

Isso inclui usar uma convenção de nomes adequada para variáveis, métodos, eventos, funções, etc.. Os nomes devem expressar a intenção do elemento representado, serem inequívocos, claros e o mais sucintos possível.

Além disso, é importante documentar o código por meio de comentários (mas sem exagero – não escreva um livro dentro do código-fonte!).

Como disse Martin Fowler, autor e desenvolvedor que ajudou a criar o Manifesto para o Desenvolvimento de Software Ágil:

“Qualquer idiota pode escrever um código que um computador consegue entender. Bons programadores escrevem código que os humanos conseguem entender.”

A qualidade do código é sempre fundamental.

Dica de leitura sobre o assunto (link afiliado):

3. Reinventar a roda.

É sempre tentador e desafiador criar nossos próprios algoritmos e bibliotecas, como algoritmos de busca, ordenação, bibliotecas de cálculos e funções variadas. Mas isso, normalmente, é altamente trabalhoso, toma um grande tempo de nosso trabalho, e pode acarretar a inserção de erros variados nos programas que estamos criando. Obviamente precisamos escrever código para nossos projetos, mas se algumas das funcionalidades que necessitamos já existem, na forma de código já pronto, talvez seja uma melhor opção usá-los.

Tente, sempre que possível, usar as bibliotecas e classes escritas por terceiros, pois no geral trata-se de código escrito e otimizado por um grupo de profissionais, cuja probabilidade de apresentar erros é baixa, e assim você poupa um tempo enorme ao não precisar escrever código que já existe pronto e testado.

Além, é claro, da alta probabilidade de seu próprio código apresentar uma série de falhas e bugs.

Reuso de código é a regra!

4. Não realizar testes e não pensar em manipulação de erros no código.

Se o programa funciona para você, não significa que irá funcionar sempre para o usuário – talvez haja alguma falha oculta, ou uma maneira específica de usar a aplicação que traga à tona problemas não previstos. Melhor detectar, tratar e eliminar essas possíveis falhas antes de entregar o produto ao usuário, para evitar problemas mais graves e custosos.

Para tal você deve lançar mão de ao menos duas técnicas: a manipulação de exceções (erros) dentro do código, e a realização de testes de software, dos mais variados tipos (unitários, de integração, etc.).

Pode ser trabalhoso (e aparentemente custoso) escrever rotinas de testes ou de manipulação de exceções, mas muito menos do que corrigir bugs em software já finalizado e em produção (além de ser, no final das contas, mais barato).

5. Somente copiar e adaptar código, sem entender como ele funciona

É extremamente comum, em desenvolvimento de software, que o programador procure trechos de código e algoritmos em sites de busca (como o famoso Stack Overflow), e use os códigos encontrados em sua aplicação, tentando adaptá-los.

Até aí, nenhum problema – afinal, isso é uma espécie de “reuso de código” por meio de compartilhamento. O problema surge quando o programador não procura realmente entender como o código opera – quais as ideias empregadas, técnicas específicas da linguagem, como a lógica foi organizada. Isso impede que o profissional aprenda com o exemplo e seja capaz de, futuramente, escrever por si próprio código sem a necessidade de “copiar e colar”.

Use os códigos compartilhados na Internet à vontade, mas procure aprender como eles foram feitos para que você também seja capaz de escrevê-los – afinal, para que os algoritmos compartilhados existam é necessário que alguém saiba como fazê-los – e esse alguém pode ser você, em algum momento.

6. Não efetuar backup de seus arquivos-fonte.

O backup é de crucial importância, e isso se aplica a quem trabalha com desenvolvimento, e também a quem trabalha com tecnologia em geral, e mesmo a quem não trabalha diretamente com tecnologia, mas usa computadores em suas atividades.

Além de backups (local/nuvem), aprenda a usar sistemas de controle de versão, como o Git ou SVN (Github é um ótimo começo).

Por exemplo, assista ao Minicurso de Git da Bóson Treinamentos em Tecnologia no YouTube para uma introdução ao assunto de controle de versão:

Leitura recomendada (link afiliado):

E por último, mas não menos importante:

7. Não praticar todos os dias (ou quase todos).

Programação é uma atividade prática, que envolve o emprego de uma série de conhecimentos, ferramentas e técnicas, muitas vezes de alta complexidade, e somente a prática constante e focada pode garantir seu aprendizado adequado e o desenvolvimento satisfatório de código funcional, em tempo hábil, e com poucos erros.

Além disso, como em tecnologia em geral o aprendizado é constante, devido à velocidade na qual as tecnologias são desenvolvidas e atualizadas, a necessidade de prática de forma sistemática se torna ainda mais evidente.

Como disse o famoso cientista da computação Alan Turing:

“Programação é uma habilidade adquirida pela prática e pelo exemplo, e não por meio de livros.”

Conclusão

Evitar que erros ocorram durante o desenvolvimento de software é uma tarefa desafiadora, mas há muitas formas de minimizarmos problemas, desde que sejam seguidas algumas recomendações simples, como as apresentadas neste artigo.

O post 7 erros que todo programador deve evitar ao desenvolver software apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.