DEV Community: Carlos Henrique Garcia Soares

🌍E se a criação do mundo fosse um sistema? Uma visão Dev. sobre Gênesis!

Carlos Henrique Garcia Soares — Mon, 06 Apr 2026 16:00:47 +0000

🌌 CodeVerse2026 – Artigo #07

🧑💻 Fala Galera Dev! 👋

Eu sei que normalmente venho aqui apresentar um projeto tech que fiz, compartilhar o código, falar de IA, backend, frontend… aquela rotina que a gente já conhece. Mas hoje eu quis fazer algo diferente. Não é um projeto de código, mas é um projeto que, se a gente parar pra pensar, é o maior de todos. 😄

Hoje, por ser um dia logo após o domingo de Páscoa, resolvi trazer um “projeto” de outro Dev… e talvez o mais experiente que já existiu. Mas calma, não quero entrar em religião, nem discutir crença ou nada do tipo. A ideia aqui é fazer uma reflexão leve, usando algo que muitos conhecem e trazendo isso para o nosso universo de programação.

E se a gente olhasse para o início de tudo… como se fosse o início de um sistema?

🧠 No princípio… o projeto começou do zero:

“No princípio Deus criou os céus e a terra, e a terra era sem forma e vazia…”

Se a gente olhar isso com a cabeça de dev, isso aqui é muito familiar. É aquele momento em que você cria um projeto novo e não tem absolutamente nada ainda. Nenhuma lógica, nenhuma interface, nenhum fluxo… só o ambiente criado.

É como abrir um projeto vazio no VS Code. Está tudo pronto pra começar, mas ainda não existe nada funcionando. É o famoso “sem forma e vazio”. Mas aí acontece algo muito importante no mesmo momento:

“E disse Deus: haja luz… e houve luz.”
Aqui não foi só criação… foi execução. Foi o momento em que o sistema começou a rodar de verdade. Se antes era só estrutura, agora virou processo. É como dar o primeiro run no sistema e ver que ele está vivo.

Ou seja, não foi só criar o ambiente… foi ligar o servidor. 😄

💡 Dia 1 — Luz e tempo: o sistema entrou em produção:

Dia 1: A Luz e o Tempo. Deus criou a luz e a separou das trevas, chamando a luz de "dia" e as trevas de "noite".

No primeiro dia não foi só sobre luz, foi sobre organização do tempo. Quando a luz é separada das trevas e passa a existir “dia” e “noite”, nasce algo essencial para qualquer sistema: o controle de ciclos.

Isso é como quando a aplicação começa a rodar com lógica. Não é só executar, é executar com ordem. É como definir o fluxo principal da aplicação, o loop, a sequência das coisas acontecendo. Sem isso, tudo vira bagunça. Com isso, tudo passa a fazer sentido. O sistema não só existe… ele funciona com ritmo.

🌐 Dia 2 — O céu: separando as camadas do sistema:

Dia 2: O Firmamento (Céu). Deus criou o firmamento para separar as águas, criando o céu e a atmosfera.

Traduzindo isso pro nosso mundo, isso aqui é arquitetura. É quando você começa a organizar o sistema em camadas e parar de deixar tudo misturado, pois sem organização fica difícil da manutenção depois.

É como separar backend de frontend, API de interface, lógica de apresentação de regra de negócio. Esse momento é fundamental, porque é aqui que o sistema começa a ficar organizado de verdade.

Sem essa separação, qualquer projeto vira uma bagunça difícil de manter. Com isso, você ganha clareza e consegue evoluir de forma modular, onde cada parte não depende da outra para funcionar e torna simples a manutenção do módulos individualmente.

🌱 Dia 3 — Terra e vegetação: estrutura e crescimento:

Dia 3: Terra Firme e Vegetação. Deus ajuntou as águas, fazendo aparecer a terra seca. Em seguida, criou a vegetação, plantas e árvores frutíferas.

No terceiro dia, aparece a terra firme e começam a surgir plantas, sementes e árvores. Aqui já vemos algo muito mais estruturado e preparado para crescer. Isso lembra muito a criação de banco de dados e estrutura de informação. Cada coisa no seu lugar, cada dado bem organizado, pronto para gerar novos dados.

Esse momento também pode ser comparado ao início da construção do frontend. É quando começamos a dar forma visual ao sistema, implementando por etapas, testando cada parte para verificar se está funcionando corretamente, ajustando bugs e validando se aquilo realmente faz sentido antes de avançar. Afinal, essa base será utilizada para sustentar tudo que vem depois.

É como preparar o terreno para os próximos elementos do sistema, os “personagens” que serão adicionados nas etapas seguintes da criação. Tudo precisa funcionar em harmonia, cada parte se conectando com a outra, criando um fluxo equilibrado onde um elemento depende do outro, assim como em uma cadeia bem estruturada dentro de um sistema.

E o mais interessante: tudo começa a crescer sozinho, seguindo regras. Isso é exatamente o que buscamos em sistemas bem feitos, algo que funcione hoje, mas que também permita evoluir amanhã.

⏱ Dia 4 — Sol, lua e estrelas: controle total do tempo

Dia 4: Luminares (Sol, Lua e Estrelas). Deus criou o Sol para governar o dia, a Lua para a noite e as estrelas, estabelecendo as estações, dias e anos.

No quarto dia, vemos um refinamento muito importante do que foi iniciado lá no começo. Se no primeiro dia o tempo começou a existir com a separação entre luz e trevas, aqui ele passa a ser organizado de forma mais precisa. Agora existem ciclos bem definidos, horários, marcações e referências claras, tudo funcionando de maneira coordenada.

A criação do sol, da lua e das estrelas não serve apenas para iluminar, mas para estruturar o tempo de forma inteligente. O sol passa a alimentar a vida na Terra, sendo essencial para processos como a fotossíntese, enquanto as estações do ano regulam ciclos naturais, crescimento das plantas e equilíbrio do ambiente. Ou seja, não é apenas organização… é um sistema que sustenta a vida de forma contínua e previsível.

Trazendo isso para o nosso mundo de desenvolvimento, é exatamente como implementar controle de tempo dentro de um sistema. É quando entram logs, agendamentos, tarefas programadas, cron jobs e até a definição correta de timezones, evitando inconsistências e garantindo que tudo funcione da mesma forma para todos os usuários.

Agora o sistema não só roda… ele roda com precisão, previsibilidade e confiabilidade. E isso, no mundo real, faz toda a diferença entre um sistema amador e um sistema profissional.

🐟 Dia 5 — Vida no sistema: funcionalidades acontecendo

Dia 5: Criaturas Aquáticas e Aves. Deus criou os seres que povoam as águas e as aves que voam sobre a terra, abençoando-os para se multiplicarem.

Aqui começam a surgir as criaturas nas águas e no céu. Traduzindo isso para o nosso mundo, é quando o sistema começa a mostrar funcionalidades reais. É o momento em que o projeto deixa de ser apenas estrutura e vira algo vivo. Algo que reage, que interage, que cresce e começa a gerar movimento dentro do ambiente. É como quando sua aplicação começa a ter usuários, dados sendo gerados e eventos acontecendo em tempo real. Aquela fase em que você olha e pensa: “agora sim, isso aqui deixou de ser só código e virou um sistema de verdade”.

Mas tem um ponto interessante aqui. Nem tudo foi criado de uma vez só, de forma desordenada. Existe uma progressão, uma construção por etapas. Mesmo olhando por uma ótica mais científica, onde se fala em evolução ao longo do tempo, ainda assim vemos um princípio muito importante: crescimento gradual.

E isso conecta diretamente com o que fazemos em desenvolvimento. Nenhum sistema robusto nasce completo. Ele é construído de forma escalonada, adicionando funcionalidades aos poucos, validando cada etapa, testando comportamentos e corrigindo possíveis falhas antes de avançar. É como se cada “dia” fosse uma sprint. Você entrega uma parte, testa, valida, garante que está funcionando e só depois parte para a próxima fase. Porque se der algum problema, o impacto é controlado, não compromete o sistema inteiro.

E essa é uma das maiores lições aqui: sistemas bem construídos evoluem com controle. Não é sair implementando tudo de uma vez. É crescer com consistência, garantindo que cada parte esteja sólida antes de seguir adiante.

🧑💻 Dia 6 — O usuário final: tudo passa a fazer sentido

Dia 6: Animais Terrestres e o Homem: Deus criou os animais terrestres e Deus criou o ser humano (homem e mulher) à sua imagem e semelhança, dando-lhes domínio sobre a criação.

No sexto dia, entram os animais terrestres, completando a criação iniciada no quinto dia e, por fim, surge o ser humano. Esse aqui é o ponto mais importante de qualquer sistema: o usuário final. Não adianta backend bonito, frontend responsivo e código organizado se ninguém usa. Tudo foi criado para chegar exatamente nesse momento.

E tem um detalhe muito interessante nesse trecho. A Bíblia diz que o ser humano foi criado à imagem e semelhança de Deus. Trazendo isso para a nossa analogia, é como se o criador tivesse colocado no “código” do ser humano algumas das suas próprias características. E uma delas é a mais poderosa de todas: a capacidade de criar e cocriar.

Nós somos os únicos seres que conseguem imaginar, desenvolver, construir e transformar o ambiente ao nosso redor. Conseguimos evoluir, adaptar, inovar e até seguir caminhos que não estavam previamente definidos. Isso é o livre-arbítrio funcionando como uma espécie de “liberdade de execução” dentro do sistema.

Ou seja, depois de estruturar todo o sistema, o criador nos coloca como usuários finais dentro desse “mundo”, como se fosse um grande mapa, quase um GTA VI versão ultra realista 😄, onde podemos interagir, criar, evoluir e dar continuidade àquilo que foi iniciado.

O ser humano representa exatamente isso: o usuário que dá propósito ao sistema. Mas não só isso. É também aquele que pode modificar, expandir e transformar tudo ao seu redor, tornando o sistema algo vivo, dinâmico e em constante evolução.

🛑 Dia 7 — O descanso: sistema estável

E no sétimo dia, Deus descansa.

E isso aqui traz uma lição muito forte, principalmente pra gente que vive criando, codando e pensando em melhorar tudo o tempo todo.

Nem sempre precisamos estar implementando novas funcionalidades. Existe um momento essencial de parar, observar, validar e garantir que tudo aquilo que foi construído está funcionando da forma correta. É o momento de olhar o sistema com mais calma, entender seu comportamento e consolidar o que já foi feito.

Isso é muito parecido com o pós-deploy. Aquele momento em que você sobe o sistema, para de adicionar novas features e começa a monitorar estabilidade, performance e experiência do usuário. E junto com isso vem aquela sensação boa de missão cumprida, de ver algo funcionando exatamente como você planejou.

Porque a verdade é que, quando ficamos apenas pensando em adicionar mais e mais coisas, muitas vezes acabamos quebrando sistemas que já estavam estáveis, funcionando bem e atendendo perfeitamente ao que foi proposto. Nem sempre mais é melhor. Descansar também faz parte do processo. É no descanso que a gente observa, aprende, corrige com mais clareza e se prepara para evoluir no momento certo.

🧠 A grande reflexão

Se a gente parar pra pensar, nada foi feito fora de ordem. Existe uma sequência muito clara: primeiro estrutura, depois organização, depois regras, depois funcionalidades e só então o usuário. Isso é exatamente como um bom projeto deve ser construído. Quando a gente pula etapas, o sistema quebra. Quando seguimos o fluxo, tudo evolui com consistência.

E trazendo isso para a nossa vida, muitas vezes a gente pede “milagres” como se tudo pudesse mudar de uma hora pra outra. Melhorar de vida, crescer financeiramente, ter saúde, resolver problemas… e não que isso seja impossível. Se a gente for pensar nessa analogia, Deus seria o “admin” do sistema. Ele poderia, sim, alterar uma linha de código e mudar tudo instantaneamente.

Mas existe um ponto importante: o sistema foi criado com regras desde o início. E essas regras valem para todos. Existe uma lógica, uma ordem, um processo. E, na maioria das vezes, o que colhemos é resultado direto do que estamos plantando.

Se queremos crescer financeiramente, precisamos nos preparar, estudar, evoluir, desenvolver habilidades. Se queremos saúde, precisamos cuidar do nosso corpo, da nossa alimentação, dos nossos hábitos. A gente sabe que um copo de veneno nos matará na hora, então evitamos. Mas muitas vezes ignoramos hábitos que fazem mal no longo prazo, simplesmente porque o efeito não é imediato.

E aí entra a reflexão: não é sobre falta de oportunidade ou falta de intervenção. Muitas vezes é sobre alinhamento com as regras do sistema. Estar preparado para quando a oportunidade aparecer. Porque quando tudo está pronto, estrutura, organização, preparo, aí sim as coisas começam a acontecer.

No fim das contas, é uma questão de perspectiva. A gente quer resultado imediato, mas sistemas bem construídos respeitam processo. E talvez a maior lição seja essa: não adianta querer pular etapas na vida, assim como não adianta pular etapas no código.

🚀 Conclusão

No final das contas, independente da forma como cada um enxerga essa história, o que dá pra tirar daqui é uma lógica muito interessante de construção. Grandes projetos não nascem prontos. Eles são feitos por etapas, com organização, com clareza e com propósito. E isso vale tanto para sistemas quanto para a nossa própria vida.

Infelizmente, dessa vez eu não tenho um link com código-fonte para compartilhar, afinal esse “projeto” não está público no GitHub. 😄 Mas isso também traz uma outra reflexão interessante: como entender o criador se somos parte da criação? Estamos dentro do sistema, vivendo as regras que foram definidas desde o início.

Talvez a melhor forma de entender quem criou tudo isso não seja olhando “de fora”, mas observando a própria criação. A forma como tudo funciona, como existe ordem, lógica, ciclos… até o tempo, como vimos, foi criado. Isso nos mostra que existe algo além da nossa própria compreensão, algo que não está limitado às mesmas regras que seguimos aqui dentro.

E talvez a maior lição pra gente como dev seja essa: não queira sair criando tudo de qualquer jeito. Comece pela base, organize bem e construa com consistência. Porque quando a fundação é sólida, o crescimento vem de forma natural.

🔥 Antes de querer escalar seu sistema… garante que ele está bem construído desde o começo. 🚀
Se gostou desse conteúdo e quer ver sobre, me segue nas redes sociais, pois posto quinzenalmente sobre tecnologia, projetos tech reais em desenvolvimento e um pouco da minha trajetória no mundo da tecnologia. Sempre de um ponto de vista bem real da situação e buscando escrever artigos bem simples e fáceis de entender!

🔗 Segue lá no GitHub: https://github.com/Carlos-CGS/CodeVerse2026
🔗 Segue lá no LinkedIn: https://www.linkedin.com/in/carlos-cgs/

🎮Como Usei IA para Criar um Jogo para Minhas Filhas em um Domingo Chuvoso

Carlos Henrique Garcia Soares — Wed, 25 Mar 2026 19:06:33 +0000

🧑💻 Fala Galera Dev! 👋

Nos artigos anteriores do CodeVerse2026 falamos bastante sobre GitHub, organização de projetos e a importância de um README bem estruturado para apresentar nosso trabalho ao mundo. Vimos também como pequenos detalhes de organização podem fazer uma enorme diferença na forma como recrutadores e outros desenvolvedores enxergam nosso portfólio.

Mas hoje eu quero trazer algo um pouco diferente. Em vez de falar apenas de organização de código ou boas práticas de documentação, quero contar uma experiência prática que tive no ano passado. Uma experiência simples, do dia a dia, mas que acabou se tornando um projeto muito interessante do ponto de vista de aprendizado com IA e Engenharia de Prompt.

Isso foi em novembro do ano passado, em um domingo chuvoso, daqueles que parecem feitos para ficar em casa sem muita pressa. Mas para quem tem criança pequena sabe que a energia dos pequenos não diminui com a chuva, e para resolver isso resolvi criar esse pequeno projeto que vamos ver a seguir...

🌧 Um domingo comum que virou um projeto

Era domingo, 02 de novembro de 2025. O clima estava meio feio aqui na minha cidade, com aquele céu cinza típico de dias chuvosos. Era um daqueles domingos preguiçosos, entre o almoço e o café da tarde, quando todo mundo fica mais relaxado em casa, tentando encontrar alguma coisa para fazer.

Em um determinado momento, uma cena curiosa chamou minha atenção na sala. Minhas filhas, de quatro e sete anos, estavam rindo, pulando e desviando como se estivessem jogando videogame. Mas havia algo estranho naquela situação: não havia controle, não havia console e não havia nenhum jogo rodando no computador.

O que estava acontecendo, na verdade, era que havia apenas um vídeo no YouTube passando na televisão. O vídeo mostrava obstáculos aparecendo na tela e as crianças simplesmente reagiam a eles como se estivessem dentro do jogo. Elas pulavam, desviavam e gritavam como se aquilo fosse uma experiência interativa.

Foi naquele momento que tive um pequeno insight. E se eu criasse um jogo de verdade para elas? Será que eu consigo fazer isso?

💡 A ideia parecia louca… mas possível

Minha primeira reação foi pensar que talvez aquilo fosse complicado demais. Afinal, eu não sou um dev com experiencia na criação de jogos. Nunca tinha parado para estudar profundamente engines de game development ou frameworks avançados para esse tipo de projeto.

Mas logo veio outro pensamento que mudou minha perspectiva.

Eu talvez não soubesse tudo sobre criação de jogos, mas sabia algumas coisas importantes. Eu sei um pouco de programação. Eu já tinha estudado e feito alguns projetos em Python, inclusive o CodeVerse2025 no qual estava terminado de dividir com a comunidade tech como consegui recriar o JARVIS. E principalmente, eu já estava começando a explorar o uso de IA como apoio no desenvolvimento de software.

Foi ai que pensei: se eu juntar programação + curiosidade + IA, talvez seja possível construir algo simples, mas divertido. E foi assim que comecei a codar.

No inicio eu não falei pra ninguém, afinal o game poderia não sair. Apenas peguei meu note enquanto elas estavam "jogando" e comecei a codar no sofá da sala. e assim o jogo foi saindo começando com algo muito importante que é a engenharia de prompt.

🤖 O papel da Engenharia de Prompt nesse processo

Antes de continuar a história, vale explicar rapidamente um conceito importante que esteve presente durante todo esse projeto: Engenharia de Prompt.

Esse nome pode parecer algo muito técnico à primeira vista, mas a ideia é relativamente simples. Engenharia de Prompt é basicamente a habilidade de conversar com uma inteligência artificial de forma clara e estratégica para obter melhores resultados.

Não se trata apenas de escrever algo como “crie um jogo”. Isso normalmente gera respostas genéricas ou incompletas. O segredo está em explicar para a IA o contexto, o objetivo e as características do que você deseja construir.

É como explicar um projeto para um colega desenvolvedor. Você precisa dizer o que imagina, como gostaria que funcionasse e quais tecnologias poderiam ser usadas. Quanto mais claro você for, maiores são as chances da IA responder de forma útil.

Foi exatamente isso que comecei a fazer.

💬 Minha primeira conversa com a IA

Quando abri o ChatGPT naquele dia, minha intenção inicial não era pedir um jogo pronto. Eu queria primeiro entender se aquilo era tecnicamente possível. Então comecei com uma pergunta simples, quase como uma curiosidade.

Perguntei se seria possível criar um jogo simples em Python que detectasse movimentos de uma pessoa através da câmera do computador. A ideia era que as crianças pudessem pular ou desviar fisicamente para evitar obstáculos no jogo.

A resposta veio rapidamente. E para minha surpresa, além da explicação conceitual, o modelo também sugeriu um exemplo de código funcional utilizando algumas bibliotecas de visão computacional.

E um detalhe, como você pode reparar ai acima, escrevi com alguns erros de português, e com um prompt sem muita estrutura, mas eu fiz questão de mostrar o meu prompt, pois quero mostrar que não precisa ser um especialista ou escrever de forma muito técnica o importante é saber passar as informações que você quer. Afinal não é sobre a IA não saber as respostas de nossas questões. Somos nós que não sabemos perguntar o que desejamos.

Entre elas as bibliotecas que me foram sugeridas estavam:

OpenCV
MediaPipe
NumPy

Essas bibliotecas permitem fazer reconhecimento de imagem e rastreamento de movimentos através da câmera. Naquele momento percebi que talvez aquele projeto realmente fosse possível.

⚙ Desenvolvimento acelerado com IA

Depois de receber o primeiro exemplo de código, importei tudo para o VS Code e comecei a testar. O código inicial ainda era bem simples, mas já mostrava que a lógica básica funcionava.

A partir daí começou a parte mais interessante do processo: iterar o projeto. Fui ajustando pequenas partes do código, corrigindo variáveis mal nomeadas, ajustando indentação e reorganizando a estrutura geral do script.

Durante essa fase utilizei bastante o GitHub Copilot, que ajudava sugerindo correções e complementando algumas partes do código. Em muitos momentos ele acelerou bastante o processo, principalmente quando eu precisava implementar pequenas funcionalidades.

Mas aqui vale destacar algo importante: a IA ajuda muito, mas não faz milagres. Em várias ocasiões precisei revisar manualmente o código gerado, corrigir lógicas que não funcionavam como esperado e até reescrever algumas partes.

O sistema de colisão, por exemplo, precisei refazer mais de uma vez até que funcionasse corretamente.

🎨 Adicionando vida ao jogo

Com a lógica básica funcionando, o próximo passo era tornar o jogo mais divertido visualmente. Afinal, não bastava apenas ter um algoritmo rodando. Era preciso criar algo que realmente fosse interessante para as crianças. Para isso comecei a buscar alguns recursos visuais e sonoros.

Os sons eu baixei do site Pixabay, que possui uma biblioteca gratuita com vários efeitos sonoros e trilhas simples. Ali encontrei música de fundo, sons de pulo e efeitos de colisão que ajudaram a dar mais vida ao jogo.

As imagens eu peguei da internet e utilizei um site chamado remove.bg para remover o fundo das figuras. Isso facilitou muito a criação dos personagens e dos obstáculos que apareceriam na tela.

Com esses elementos adicionados, o jogo começou a ganhar forma. Em menos de duas horas eu já tinha algo rodando, mas calma lá. Tudo rodou em menos de duas horas, mas nesses duas horas tiveram bastantes percalços, e muitas dificuldades que foram superadas sem se apavorar, buscando identificar onde estava os problemas e resolve-los.

⚠ Problemas que apareceram no caminho

Nem tudo foi simples durante o desenvolvimento. Um dos problemas mais curiosos que enfrentei foi com o carregamento das imagens do jogo.

Passei bastante tempo tentando entender por que os sprites não estavam aparecendo corretamente. Depois de investigar um pouco mais percebi que o erro era algo extremamente simples. Eu havia nomeado a pasta como “sprits” em vez de “sprites”.

Esse pequeno erro de digitação estava impedindo que o jogo encontrasse os arquivos corretamente. Depois de corrigir o nome da pasta tudo voltou a funcionar.

Esse tipo de situação mostra algo importante: muitas vezes o problema não está no algoritmo complexo, mas em detalhes simples.

👨👩👧👦 O momento mais importante do projeto

Quando finalmente mostrei o jogo para as meninas, aconteceu algo muito interessante.

Elas começaram a jogar imediatamente. Levantavam as mãos e o personagem pulava de verdade, desviavam dos obstáculos e competiam para ver quem conseguia fazer mais pontos. O que antes era apenas um vídeo passivo no YouTube se transformou em uma competição saudável e interativa dentro de casa.

No final das contas até meu filho mais velho acabou entrando na brincadeira, tentando superar suas irmãs mais novas, chamando até minha esposa a tentar superar seus recordes de pontuação. Eu, a pessoa que escrevi o jogo não fiquei em primeiro lugar na pontuação, afinal não tenho muita prática com esse tipo de game. kkkkkk

Foi naquele momento que percebi algo curioso: a tecnologia, que muitas vezes é vista como algo que isola as pessoas, mantendo uma comunicação virtual e distante, etc, mas naquele instante estava fazendo exatamente o contrário. Ela estava aproximando todos de casa.

🧠 O que aprendi com Engenharia de Prompt

Durante o desenvolvimento desse pequeno projeto percebi que alguns princípios são extremamente importantes quando usamos IA como apoio no desenvolvimento.

O primeiro deles é a clareza na descrição do problema. Sempre que eu explicava de forma detalhada o que queria, a resposta da IA vinha muito mais útil e alinhada com minha intenção.

Outro ponto importante foi dividir o projeto em partes menores. Em vez de pedir o jogo inteiro de uma vez, fui construindo o projeto passo a passo. Primeiro o motor básico, depois os obstáculos, depois o sistema de pontuação.

Também percebi que reescrever o prompt muitas vezes fazia diferença. Quando a resposta não vinha exatamente como eu esperava, eu reformulava a pergunta e explicava de outro jeito.

Esse processo me ensinou algo muito importante: o prompt é apenas o início. O verdadeiro trabalho está em entender o que a IA gera e saber adaptar aquilo para o seu projeto.

🎮 O jogo: Kids Runner

No final das contas o projeto recebeu o nome de Kids Runner. Ele foi desenvolvido utilizando Python e a biblioteca Pygame, que é bastante utilizada para jogos simples e protótipos educacionais.

O jogo possui três personagens jogáveis inspirados em emoções: Alegria, Tristeza e Raiva. O jogador pode escolher entre eles antes de iniciar a partida.

A lógica é simples. O personagem precisa desviar de obstáculos que aparecem na tela enquanto a pontuação aumenta conforme o tempo de sobrevivência.

O jogo pode ser controlado pelo teclado, mas também possui uma versão experimental que utiliza reconhecimento de movimentos pela câmera, levantando os braços o personagem pula, virando o tronco de seu corpo para os lados o personagem se movimenta entre as três faixas para desviar dos obstáculos.

Cada obstáculo evitado aumenta a pontuação. Após dez colisões o jogo termina e o placar final é exibido.

🚀 Concluindo...

Esse projeto começou com algo extremamente simples: um domingo chuvoso e duas crianças brincando na sala. Mas acabou se tornando uma experiência muito rica do ponto de vista de aprendizado para mim, afinal foi nesse momento que eu percebi que mesmo tendo pouco conhecimento sobre certa tecnologia, junto da IA e a base que carrego comigo de programação, consigo crie projetos reais que impactam a vida das outras pessoas.

Criar esse jogo me mostrou que hoje temos ferramentas incríveis à nossa disposição. Com o apoio de IA e um pouco de curiosidade, é possível transformar ideias simples em projetos reais em muito menos tempo do que imaginávamos alguns anos atrás.

Mas também ficou claro que a IA não substitui o desenvolvedor. Ela acelera processos, sugere caminhos e ajuda a resolver problemas, mas quem realmente constrói o projeto continua sendo o ser humano. A partir daí comecei a dedicar certo tempo para tirar projetos antigos do papel, como o jogo WoldWar que apresentei no artigo03 dessa serie do CodeVerse2026

No final das contas, esse pequeno jogo me ensinou mais sobre programação, criatividade e uso prático da IA do que muitos cursos puramente teóricos. E talvez essa seja a grande lição.

A tecnologia é mais poderosa quando usamos ela para criar, aprender e aproximar pessoas, saindo da teoria e colocando em prática!
Se esse conteúdo te ajudou de alguma forma peço que de uma estrela lá no repositório do projeto no meu GitHub, segue lá nas minhas redes sociais para mais conteúdos como esse:

🔗 Segue lá no GitHub: https://github.com/Carlos-CGS/CodeVerse2026
🔗 Segue lá no LinkedIn: https://www.linkedin.com/in/carlos-cgs/
🔗 Projeto no GitHub: https://github.com/Carlos-CGS/Jogo-Kids-Runner

🎮Voltei num projeto de 2017 e finalizei um jogo completo em 3 dias (offline + online)

Carlos Henrique Garcia Soares — Wed, 25 Mar 2026 18:55:33 +0000

🌌CodeVerse2026 - Artigo#03

👋Fala Galera Dev!🧑💻🎮

Tem um tipo de satisfação que só quem programa entende: voltar num projeto antigo, aquele que você começou cheio de vontade… e abandonou porque era complexo demais na época — e finalmente concluir de verdade.

Esse foi o caso do meu game World War.

Eu comecei esse projeto em 2017 como um jogo de tabuleiro digital de guerra, baseado em cartas. Na época eu estava aprendendo PHP, JavaScript e banco de dados. Eu até avançava, mas sempre travava em coisas que hoje parecem “óbvias”: organização, rotas, estrutura, bugs difíceis de rastrear, e principalmente a parte online.

Em janeiro de 2026, eu resolvi voltar e concluir.

E o mais curioso: em 3 dias o projeto ficou pronto, com modo offline e modo online.

💻O que eu fiz nesses 3 dias (sem romantizar):

Eu não “criei do zero em 3 dias”. Eu já tinha um projeto iniciado, mas estava parado e com várias partes incompletas. O que eu fiz foi entrar com foco total e transformar aquilo num projeto publicável e organizado.

Dividi assim:

Dia 1: finalizei o modo offline, ajustando cartas, sons, tabuleiro e a lógica do jogo contra IA.
Dia 2: implementei e estabilizei o modo online (multiplayer), com matchmaking, sincronização de turno, abandono e registro de resultados.
Dia 3: organizei o projeto inteiro para ficar claro, fácil de manter e pronto para deploy.

O que eu aprendi aqui é simples: às vezes o que falta não é “mais código”… é organização e um caminho claro do que fazer primeiro.

📆O que mudou de 2017 pra cá (e por que isso importa pra dev júnior):

A maior diferença não foi “eu virei gênio”, foi que eu comecei a pensar como projeto real.

Quando a gente é júnior, a gente quer fazer a feature funcionar. Quando a gente começa a evoluir, a gente percebe que o projeto precisa ser:

legível para quem chega depois,
estável em produção,
minimamente seguro,
e fácil de manter.

E foi isso que eu busquei, em cada parte do código, estavam pensando no todo, não apenas em fazer funcionar.

🏗️Uma parte que quase ninguém mostra: a estrutura do projeto:

Eu organizei o World War como um “MVC simplificado”, separando o que é público do que é servidor.

public/ ficou com os HTML (login, regras, mapas, jogo offline etc.)
src/ ficou com o backend em PHP (autenticação, matchmaking, sincronização...)
assets/ com CSS, JS, imagens e sons
database/ com os scripts SQL
docs/ com documentação completa e checklist

Isso parece “detalhe”, mas muda tudo. Resolve 404, resolve bagunça de caminho, resolve manutenção. E principalmente: deixa o projeto com cara de produto, não de pasta aleatória.

🌐Modo Online: onde eu mais aprendi:

O modo online foi a parte mais divertida e mais desafiadora, pois o jogo ja estava funcionando, e replicar essa mesma estrutura com o modo online foi bem difícil, pois a acda implementação de matchmaking e novas regras, eu alterava outras regras que já estavam funionando no modo offline.

Eu implementei um fluxo com:

matchmaking automático (buscar_partida.php)
sincronização com polling a cada 2 segundos (sincronizar_partida.php)
controle de turno e estados da partida
abandono de partida e derrota automática (abandonar_partida.php)
registro de resultado e atualização de stats no banco (registrar_resultado.php)

E tudo isso usando:

PHP + Sessions
MySQL
JavaScript Vanilla consumindo endpoints PHP

O jogo basicamente funciona assim: o navegador faz requisições frequentes, o servidor responde com JSON, e o client atualiza a UI com base no estado da partida. Não é WebSocket ainda mas está funcional, estável e bem organizado.

🛡️Segurança: fiz o básico bem feito:

Eu também não quis deixar o projeto “aberto” de qualquer jeito.

A estrutura tem .htaccess para bloquear acesso direto a pastas sensíveis (database/, config/, src/). No PHP, apliquei:

validação de sessão em rotas e endpoints
prepared statements para evitar SQL injection
hash de senha com bcrypt
e proteção via session para evitar abusos básicos

Dev júnior costuma ignorar isso no começo (eu ignorei também). Mas a verdade é: segurança é parte do projeto, mesmo em projeto pessoal.

👾O papel do GitHub Copilot nisso tudo:

Eu usei o GitHub Copilot como apoio principalmente para: acelerar correções repetitivas, revisar caminhos, organizar estrutura, identificar erros de lógica e sugerir soluções.

Mas o ponto é: a IA não “concluiu” o projeto por mim. Ela reduziu o atrito e aumentou velocidade, gerando os códigos que eu pedia, as vezes eu memso os escrevia, pois escrever ainda é o melhor jeito de se obter o que deseja, enquanto eu mantive a visão e as decisões.

Pra mim foi uma aula prática de como IA pode ser um copiloto de verdade, e não um “atalho”.

🔰Se você é dev júnior, aqui vai a mensagem principal:

Se você tem um projeto parado, antigo, incompleto… volta nele. Porque finalizar um projeto ensina coisas que tutorial nenhum ensina:

Você aprende a organizar. Você aprende a corrigir bug de verdade. Você aprende a terminar. Eu mesmo aprendi bastante concluindo esse que foi um dos meus primeiros projetos que pensei em criar, e para mim foi muito mais do que um conclusão de um código, veio com aquela sensação de dever cumprido, de não deixar nada para trás, de não esquecer dos seus sonhos, de saber que com esforço conseguimos fazer e criar o que imaginamos.

📹Onde ver o jogo e o código

Eu vou publicar um vídeo aqui no LinkedIn mostrando o World War funcionando. 🧠 E quem quiser estudar o projeto, o código e a estrutura completa, deixei tudo no meu GitHub.

Link para acessar o Vídeo no LinkedIn: Link do Video
Link para acessar o Repositório no GitHub: https://github.com/Carlos-CGS/WorldWar

Se você está começando e quer uma base real de: PHP + MySQL + JavaScript + rotas + multiplayer com polling + organização de projeto …esse repositório pode te ajudar.

Seguimos evoluindo. Um projeto concluído de cada vez. 🚀🎮

Projeto J.A.R.V.I.S. - Como Criei um Assistente Virtual do Zero que Conversa e Executa Tarefas

Carlos Henrique Garcia Soares — Fri, 30 Aug 2024 17:56:52 +0000

Olá galera Dev!
Hoje quero compartilhar com a comunidade as últimas atualizações do meu projeto pessoal, que tem sido uma grande aventura no mundo da programação: meu assistente virtual, J.A.R.V.I.S., inspirado no assistente do Homem de Ferro.

Sempre tive o sonho de criar um assistente que interagisse comigo e me auxiliasse no dia a dia. Após muito estudo em desenvolvimento de software e programação, através de cursos, bootcamps e certificações, tive o insight de iniciar esse projeto. Combinando a API Google Gemini com um aplicativo Python que realiza reconhecimento de voz, texto para fala (text-to-speech) e fala para texto (speech-to-text), estou finalmente trazendo esse sonho à realidade.

O que é o J.A.R.V.I.S.?
O J.A.R.V.I.S. (Just A Rather Very Intelligent System) é um assistente virtual desenvolvido em Python, que combina diversas bibliotecas nativas e de terceiros para realizar tarefas automatizadas através de comandos de voz. A interface gráfica foi criada usando tkinter, e as funcionalidades incluem desde a abertura de aplicativos até a realização de buscas na web e a transcrição de textos.

Ao iniciar, o assitente faz uma paresentação inicial dizendo o texto abaixo:

"Bom dia Sr. Carlos, hoje é dataAtual, são horaAtual, a temperatura em seuEstado é de temperaturaAtual. Me chamo Jarvis, se precisar de mim, diga o meu nome.

O assistente fica em modo de espera fazendo a captura de audio até que o usuário diga a palavra JARVIS, quando é dita o assistente retorna uma das sete resposta que adicionei para deixa-lo mais dinâmico, e depois aguarda que o usuário diga o qual dos comandos abaixo deseja que ele execute.

respostas = [
    "Como posso te ajudar?",
    "Sim senhor Carlos?",
    "Às suas ordens senhor?",
    "Pois não senhor?",
    "Estou aqui senhor?",
    "O que posso fazer pelo senhor?",
    "Pronto senhor?",
]

Funcionalidades do J.A.R.V.I.S.
O J.A.R.V.I.S. é capaz de realizar uma série de comandos através de voz, que foram implementados para tornar o assistente mais interativo e útil no dia a dia. Abaixo, apresento todas as funcionalidades atribuidas ao meu assitente até o momento, vou criando e adiconando mais complexidade a medida que vou tendo insights, tornando-o mais completo:

Pesquisar na Web:

Pesquisar na Web: Ao dizer "Jarvis, pesquisar...", o assistente faz uma busca no Google utilizando a API Generative AI do Google com o que foi dito após a palavra pesquisar. Também criei um parâmetro no qual quando não é dito nada após a palavra pesquisar o assitente retorna uma pergunta perguntando o que eu desejo pesquisar. O comando é capturado e processado da seguinte forma:
Descrição: Realiza uma busca no Google sobre o termo solicitado e retorna uma resposta discursiva.

if "pesquisar" in comando:
   pesquisa = comando.split("pesquisar", 1)[1].strip()
   if pesquisa:
        self.label.config(text="Um momento, estou pesquisando.")
        falar("Um momento, estou pesquisando.")
        resposta = pesquisar_no_google(pesquisa)
        falar(resposta)
   else:
       self.label.config(text="Sobre o que deseja saber?")
       falar("Sobre o que deseja saber?")
       with sr.Microphone() as source:
           audio = microfone.listen(source)
      try:
          pesquisa = microfone.recognize_google(audio, language="pt-BR")
          self.label.config(text="Só um momento, estou pesquisando.")
          falar("Só um momento, estou pesquisando.")
          resposta = pesquisar_no_google(pesquisa)
          falar(resposta)
      except sr.UnknownValueError:
          self.label.config(text="Não consegui entender a pesquisa.")
          falar("Não consegui entender a pesquisa.")

Modo Conversa:

Comando de voz: "Iniciar modo conversa"
Descrição: Entra em um modo onde o J.A.R.V.I.S. pode manter uma conversa contínua sobre diversos tópicos até que o usuário decida encerrar, utilizando o comando "encerrar modo conversa".

Abrir YouTube:

Comando de voz: "Abrir YouTube"
Descrição: Solicita o nome de uma música e abre a busca correspondente no YouTube, conforme detalharei melhor em explicão abaixo desta funcionalidade.

Consultar Temperatura:

Comando de voz: "Qual a temperatura em [cidade]"
Descrição: Informa a temperatura atual em uma cidade específica utilizando a API do OpenWeather, a conexão com esta API explico melhor na parte final deste artigo, porém segue abixo como utilizo esta solicitação de temperatura na estrutura de decisão.

elif "Qual a temperatura em" in comando:
    cidade = comando.split("Qual a temperatura em", 1)[1].strip()
    clima = obter_temperatura(cidade)
    falar(clima)
    print(clima)

Consultar Previsão do Tempo:

Comando de voz: "Previsão do tempo em [cidade]"
Descrição: Fornece a previsão do tempo para o dia seguinte na cidade informada.

Abrir Navegador:

Comando de voz: "Abrir navegador"
Descrição: Abre o navegador padrão do sistema.

Abrir Calculadora:

Comando de voz: "Abrir calculadora"
Descrição: Abre a calculadora do sistema.

Abrir Paint:

Comando de voz: "Abrir Paint"
Descrição: Abre o Microsoft Paint.

Abrir Bloco de Notas:

Comando de voz: "Abrir bloco de notas"
Descrição: Abre o Bloco de Notas do sistema.

Abrir Excel:

Comando de voz: "Abrir Excel"
Descrição: Abre o Microsoft Excel.

Abrir Word:

Comando de voz: "Abrir Word"
Descrição: Abre o Microsoft Word.

Abrir CMD:

Comando de voz: "Abrir CMD"
Descrição: Abre o Prompt de Comando do Windows.

Consertar Internet:

Comando de voz: "Consertar internet"
Descrição: Inicia o solucionador de problemas de rede do Windows.

Consultar Horário:

Comando de voz: "Que horas são"
Descrição: Informa o horário atual.

Consultar Data:

Comando de voz: "Que dia é hoje"
Descrição: Informa a data atual.

Transcrever Texto:

Comando de voz: "Transcrever"
Descrição: Converte um comando de voz em texto e salva em um arquivo no desktop.

Desligar Sistema:

Comando de voz: "Desligar sistema"
Descrição: Finaliza a execução do J.A.R.V.I.S. e encerra o programa.

Como foram implementadas algumas da funções principais do J.A.R.V.I.S.

Interface Gráfica com Tkinter
Para criar a interface gráfica do J.A.R.V.I.S., utilizei a biblioteca tkinter. O código cria uma janela simples com um botão para iniciar o assistente e um círculo animado que muda de cor conforme o assistente "fala". O círculo foi desenhado em um Canvas, e a animação ocorre por meio de um loop que ajusta as coordenadas do círculo, simulando um movimento pulsante.

self.root = root
self.root.title("Jarvis")
self.root.geometry("200x190")
bg_color = "#006400"
fg_color = "#000000"
self.root.configure(bg=bg_color)

Essas linhas definem o layout básico da janela, enquanto o botão para iniciar o assistente é configurado da seguinte maneira:

self.btn_iniciar = tk.Button(root, text="Iniciar Assistente", command=self.iniciar_assistente, bg=fg_color, fg=bg_color)

Quando o botão é pressionado, o assistente é iniciado em uma thread separada para garantir que a interface continue responsiva.

Síntese de Voz e Reconhecimento de Fala
O motor de síntese de voz é criado usando a biblioteca pyttsx3, que permite que o assistente "fale" as respostas. O código a seguir inicializa o motor e define a função para falar:

engine = pyttsx3.init()
def falar(texto):
   engine.say(texto)
   engine.runAndWait()

Para o reconhecimento de fala, utilizei a biblioteca speech_recognition. Ela permite capturar áudio do microfone e transcrever em texto usando a API do Google:

microfone = sr.Recognizer()
with sr.Microphone() as source:
   audio = microfone.listen(source)
   comando = microfone.recognize_google(audio, language="pt-BR")

Implementação de Busca no YouTube
O assistente também pode buscar vídeos no YouTube. Isso é feito através da API do YouTube Data, onde uma consulta é feita e o link do vídeo é retornado. A implementação básica seria algo assim:

query = "o que você quer buscar"
search_url = f"https://www.googleapis.com/youtube/v3/search?part=snippet&q={query}&key=sua_chave_api"
response = requests.get(search_url)

O J.A.R.V.I.S. então captura o link do primeiro resultado e o abre no navegador.

Como Obter e Configurar as APIs do OpenWeather e Google
Para integrar APIs ao J.A.R.V.I.S., é fundamental saber como obter as chaves e configurá-las corretamente. Abaixo, explico o processo para obter e configurar as APIs do OpenWeather e Google, com exemplos práticos de uso no código e de forma gratis. Porém deve ser evitada a divulgação de suas chaves API para terceiros, pois não sabemos como se manterá as políticas de gratuitidade de uso destas APIs ao longo do tempo.

Criação e Implementação da API de Previsão do Tempo
Neste Projeto usei a API do OpenWeather para obter informações sobre o clima. Após configurar a chave API, o J.A.R.V.I.S. pode fazer requisições HTTP para obter dados como temperatura e previsão do tempo para uma localização específica de forma gratuita e em tempo real, conforme o implementado na parte de código exemplificada abaixo:

api_key = "sua_chave_api"
base_url = "http://api.openweathermap.org/data/2.5/weather?"
cidade = "São Paulo"
complete_url = base_url + "appid=" + api_key + "&q=" + cidade + "&units=metric"
response = requests.get(complete_url)

Essas informações são então processadas e comunicadas ao usuário através da síntese de voz.

Como Obter a Chave API do OpenWeather

Acesse o Site: Vá até o site do OpenWeather. - https://openweathermap.org/

Crie uma Conta: Se você ainda não possui uma conta, crie uma gratuitamente.
Obtenha a Chave de API: Após fazer login, navegue até a seção de "API Keys" no seu painel de usuário.
Clique em "Create Key" para gerar uma nova chave.
Anote a Chave: A chave gerada será usada em suas requisições para acessar os dados de previsão do tempo.

Criação e Implementação da API do Google
Para permitir que o J.A.R.V.I.S. realize pesquisas na web e interaja em modo conversa, utilizei a API Generative AI do Google. É necessário configurar uma chave API para autenticar as requisições.

Essa chave permite que o assistente envie consultas ao Google e receba as respostas que são posteriormente sintetizadas em voz.

Obtenção e Configuração da API do Google

Acesse o Google AI Studio: Vá até o site do Google AI Studio. - https://aistudio.google.com/app/apikey
Crie uma Conta ou Faça Login: Use sua conta Google para acessar a plataforma.
Obtenha a Chave de API: No painel, você poderá criar uma nova chave de API que será usada para acessar os serviços da Google AI.
Configure a Chave no Código: Utilize a chave gerada para configurar as requisições do seu assistente.

Exemplo de Configuração no Código:

Configurei uma API do google para realizar buscas com respostas estilizadas. Coloquei toda esta implematção dentro de uma função que é chamada quando é feito é iniciado o modo pesquisa ou modo conversa nas funcionalidades do assitente passando como parâmetros a fala do usuário a qual ele deseja pesquisar.

Para garantir uma resposta mais acertiva, passo na pesquisa elém da solicitação do usuário, as regras que vão junto da solicitação a ia do goole para obter uma resposta mais assertiva, conforme explicado no código abaixo:

def pesquisar_no_google(pesquisa):
   regras = """
   > Resposta em forma discursiva sem falar os asteristicos que fazem o negrito das respostas,
   > Você é o Jarvis, assistente pessoal do Carlos,
   > Use o mesmo tipo de humor do Jarvis IA do homem de ferro,
   > Se limite a respostas objetivas entre 20 a 40 palavras dependendo da complexidade da pergunta e responda a questão:"""

   # Configurando a API do Google
   google_api_key = "sua_chave_de_api_aqui"
   genai.configure(api_key=google_api_key)

   # Configurando a Temperatura das Respostas
   configurar_geracao = {
       "candidate_count": 1,
       "temperature": 0.9,
   }

   # Configurando os Níveis de Segurança das Respostas
   configurar_seguranca = {
       "HARASSMENT": "BLOCK_NONE",
       "HATE": "BLOCK_NONE",
       "SEXUAL": "BLOCK_NONE",
       "DANGEROUS": "BLOCK_NONE",
   }

   # Definindo o Modelo Usado para Pesquisa
   model = genai.GenerativeModel(
       model_name="gemini-1.0-pro",
       generation_config=configurar_geracao,
       safety_settings=configurar_seguranca,
   )

   # Configurando o Histórico de Pesquisa
   chat = model.start_chat(history=[])
   response = chat.send_message(regras + pesquisa)

   return response.text

Configurações Específicas:
Modelo: Defino o modelo utilizado como o gemini-1.0-pro;
**Temperatura: **Ajustada para 0.9 para permitir respostas mais criativas.
**Níveis de Segurança: **Configurados para não bloquear qualquer conteúdo ofensivo, garantindo respostas sem filtros, caso seja necessário obter informações deste tipo de informações.

Conclusão
Esse projeto começou sem grandes pretensões, mas tem se tornado uma plataforma para testar e implementar novas funcionalidades à medida que avanço em minha jornada de aprendizado. Quem sabe, um dia, eu consiga ter um J.A.R.V.I.S. tão poderoso quanto o do Homem de Ferro!

Segue o link do repositório onde está todo o código deste projeto para ser clonado e utilizado por você para aprimora-lo e adpata-lo ao seu dia a dia: https://github.com/Carlos-CGS/Projeto_J.A.R.V.I.S./tree/main

"Vamos Disseminar os Conhecimentos e Transbordar tudo o que Aprendemos!"

Para acompanhar meu trabalho, sigam minhas redes sociais, onde posto conteúdos semanais:

LinkedIn: https://www.linkedin.com/in/carlos-cgs/

GitHub: https://github.com/Carlos-CGS

Personalize a Musica de Inicialização do seu Windows 10 com Audio do J.A.R.V.I.S.

Carlos Henrique Garcia Soares — Tue, 18 Jun 2024 16:12:11 +0000

Olá mais uma vez galera Dev !
Hoje vamos abordar uma funcionalidade que muitos usuários do Windows 7 usavam e que infelizmente não está disponível de forma nativa no windows 10.
No Windows 7, era possível configurar sons personalizados para diversos eventos do sistema, incluindo o logon. No Windows 10, essa funcionalidade foi simplificada, e a opção de definir uma música personalizada para o logon foi removida. Neste artigo explicarei o passo a passo de com um pequeno script VBS e alguns passos simples, poder restaurar essa funcionalidade e personalizar o som de inicialização do Windows 10. Vou mostrar todo o passo a passo de como criar essa funcionalidade, de forma simples e rápida, vamos lá.

Passo a Passo
1. Escolha a Música
Primeiro, escolham a música que vocês querem tocar quando o Windows iniciar. A música deve estar em um formato compatível, como MP3.

2. Coloque a Música em um Local Fixo
Para garantir que o script funcione sem problemas, salvem a música em uma pasta que não será movida ou deletada. Por exemplo, usem o caminho

C:\Música\Jarvis.mp3.

3. Criar um Script VBS
Agora vamos criar um script VBS que vai tocar a música ao fazer logon no Windows.
Abra o Bloco de Notas (Notepad):
Copiem e colem o seguinte código, substituindo essa parte do código ("C:\Música\BootJarvis.mp3") pelo seu caminho onde salvou seu audio.mp3;

Set objShell = CreateObject("WMPlayer.OCX")
Set objMedia = objShell.newMedia("C:\Música\BootJarvis.mp3")
objShell.currentPlaylist.appendItem(objMedia)
objShell.controls.play
Do While objShell.playState <> 1 ' Wait until the song finishes
    WScript.Sleep 100
Loop

Salvem o arquivo como iniciar.vbs:

4. Colocar o Script na Pasta de Inicialização
Para finalizar devemos garantir que o script seja executado toda vez que o Windows iniciar, e para que isso ocorra, vamos coloca-lo dentro de uma pasta do sistema, chamada shell:startup;

5. Abram a pasta de inicialização:

Pressione Windows + R, digitem shell:startup e pressionem Enter. Isso abrirá a pasta de inicialização.
Movam o arquivo iniciar.vbs para essa pasta
Arraste o arquivo iniciar.vbs que vocês criaram para a pasta de inicialização.

6- Testar o Script
Para garantir que tudo está funcionando, reiniciem o computador ou façam logoff e logon novamente. Se tudo deu certo, a música escolhida deve tocar quando o Windows iniciar.

Observações Importantes
Para funcionar corretamente, se atente para que o caminho da música no script está correto e que o Windows Media Player está instalado no sistema.
Se a música não tocar, verifiquem se o Windows Media Player consegue reproduzir o arquivo MP3 manualmente, para testar se o seu áudio esta 100% funcional.

E é isso, galera Dev! Com esses passos simples, você pode personalizar o som de inicialização do Windows 10 e começar o dia com a música que vocês mais gostam. Eu coloquei o audio de inicialização do Homem de Ferro acordando o Jarvis, o qual disponibilizei no meu GitHub no link abaixo, porém fiquem a vontade de personalizarem com a música que mais lhe agradem. Espero que tenham curtido a dica! e ter ajudado um pouco mais. Até a próxima!

"Vamos Disseminar os Conhecimentos e Transbordar Tudo o que Aprendemos"
Segue o caminho do GitHub onde coloquei este áudio citado: Download - BootJarvis.MP3
Segue lá no LinkedIn: LinkedIn - Carlos-CGS

Ebook - Do Zero ao J.A.R.V.I.S. - Criando seu Assistente Personalizado com IA e Python

Carlos Henrique Garcia Soares — Fri, 14 Jun 2024 20:21:49 +0000

Olá mais uma vez galera Devs!
Hoje venho trazer um e-book que elaborei junto a um bootcamp da DIO que me apresentou todo o caminho das pedras para elaborar e-books de forma profissional e simples. Gratidão.
Neste e-book ensino o passo a passo e de forma prática como recriar o J.A.R.V.I.S., assistente pessoal do Homem de Ferro.
Sobre o projeto J.A.R.V.I.S, coloco em prática conceitos do curso da Alura com o Google sobre integração de APIs do Gemini, além de utilizar diversos conceitos sobre Python que aprendi durante a minha jornada de desenvolvedor.
O J.A.R.V.I.S funciona como se fosse a Alexa ou a Siri, respondendo a comandos de voz com através da biblioteca speech_recognition. Ele possui um comando de pesquisa que utiliza uma API do Google que o conecta diretamente com o Google Gemini e obtem as respostas solicitadas. O Jarvis também pode executar e abrir diversas funções em seu computador como calculadora, paint, word, excel, etc. utilizando a biblioteca OS para interagir diretamente com seu sistema operacional. Todas essas funcionalidades interagindo de forma iterativa com o usário entendo o que é dito e retornando respostas de audio.

Segue link da publicação em meu LinkedIn:
https://www.linkedin.com/posts/carlos-cgs_do-zero-ao-jarvis-carlos-cgs-activity-7202264831473684480-HX9y?utm_source=share&utm_medium=member_desktop

_Vamos Disseminar os Conhecimentos e Transbordar Tudo o que Aprendemos!
_
Segue lá no GitHub: https://github.com/Carlos-CGS
Segue lá nos LinkedIn: https://www.linkedin.com/in/carlos-cgs/

O que é e como trabalhar com Ambientes Virtuais em Python

Carlos Henrique Garcia Soares — Mon, 29 Apr 2024 19:23:15 +0000

O que são Ambientes Virtuais?
Nada mais é do que um ambiente isolado no Python. Sendo assim uma área segura, onde é possível instalar bibliotecas e suas exigências, sem afetar a instalação global do Python ou outros projetos. Essa configuração possibilita o desenvolvimento em projetos distintos com versões diferentes de bibliotecas e até mesmo versões distintas do Python, sem gerar nenhum tipo de conflito. Fazendo uma analogia, é bem parecido com o conceito de máquina virtual, onde é instalado um novo SO dentro de um computador em funcionamento. Sendo este novo SO totalmente independente do sistema operacional que está inserido/instalado.

Para que serve os Ambientes Virtuais em python?
Devido a grande abundância de bibliotecas e constante aprimoramento de versões das linguagens de programação como o exemplo do Python, administração de dependências e harmonização entre as versões da linguagem de programação se tornam um desafio para os programadores.

Vamos supor que há um ano atrás você trabalhava para o ClienteA, codava um programa em python utilizando a versão 3.10 junto da biblioteca Pandas.

E hoje em dia, você está codando o ClienteB, criando um novo aplicativo, porém com a versão mais atualizada do pyhthon 3.12 e com a biblioteca Django.

Se por algum motivo o Cliente antigo ClienteA solicitasse uma manutenção no código dele, você teria dificuldades de faze-las. Pois as versões estariam incompatíveis e você não tem mais a biblioteca Pandas , pois a desinstalou e instalou a biblioteca Django em seu lugar.

É nesse ponto que o Ambiente Virtual resolve o nosso problemas. Criando um ambiente particular, onde você pode manter todo a sua configuração atual que está utilizando, e criar um ambiente virtual para fazer a manutenção ou desenvolvimento de algum código em específico. como no caso citado acima.

Por que usar Ambientes Virtuais?
Separação de Necessidades: Cada trabalho pode possuir suas próprias exigências, e um ambiente isolado assegura que essas necessidades não interfiram em outras aplicações.
Possibilidade de Utilização de Diversas Versões: Através de ambientes virtuais, torna-se viável a utilização de distintas versões do Python em projetos individuais. Essa funcionalidade é especialmente valiosa quando se faz necessário manter um projeto antigo que não é compatível com a versão mais atual do Python disponível.
Garantir a replicabilidade do ambiente de desenvolvimento ao compartilhar o código com colegas é fundamental. Utilizar ambientes virtuais é a chave para assegurar que todas as dependências estejam presentes e o ambiente possa ser reproduzido com precisão.
Gestão Facilitada de Pacotes: Através de um ambiente virtual, é possível realizar a instalação de pacotes utilizando o pip (Python Package Installer) sem depender de autorizações de administrador. Essa prática simplifica a administração de pacotes e agiliza o desenvolvimento de projetos.

Como Usar Ambientes Virtuais?
O Python disponibiliza uma biblioteca interna chamada venv para a criação de ambientes virtuais. Abaixo segue um exemplo simples de como criar e ativar e utiliza-lo:

# Criar um ambiente Virtual:
python -m venv meu_ambiente_virtual

# Ativar o Ambiente Virtual:
WINDOWS      -      meu_ambiente_virtual\Scripts\activate
MAC OU LINUX -      source meu_ambiente_virtual/bin/activate

# Desativar o Ambiente Virtual:
deactivate

O ambiente virtual em Python é uma ferramenta essencial para qualquer desenvolvedor Python. Criando um ambiente controlado e isolado para desenvolver projetos de forma eficiente e prática. Garantindo compatibilidade de versões, gerenciamento simplificado de pacotes e reprodutibilidade.

Vamos Disseminar os Conhecimentos e Transbordar Tudo o que Aprendemos!

Segue o Link do meu LinkedIn: LinkedIn

Segue o Link do meu GitHub: GitHub

Domine a escrita de Códigos Python com PEP8 e suas bibliotecas

Carlos Henrique Garcia Soares — Fri, 26 Apr 2024 14:49:16 +0000

PEP 8: O Manual de Estilo Simplificado para Python
Pense em estar se divertindo com um conjunto de peças de montar. Você as arruma de forma que fiquem agradáveis e compreensíveis, não é mesmo? Pois bem, o PEP 8 é como um guia dessas regras para estruturar o seu código Python.

O que é o PEP 8 (Proposta de Aprimoramento Python)?
PEP é um acrônimo para: "Proposta de Aprimoramento Python" e seu número de identificação é o 8, apenas para referência. PEP 8 é um guia que fornece orientações para a escrita de códigos em Python de maneira clara e compreensível obedecendo uma convenção de escrita de código, com a intenção de manter o código consistente e legível.

Por que é importante?
Vamos fazer uma analogia onde você é o dono de um quarto de brinquedos, e quando você os organiza consegue entender onde coloca cada tipo de brinquedo, em qual prateleira estão os carros, em qual gaveta estão os lápis de cor, em qual armário estão os jogos de tabuleiro. Porém sem a devida identificação correta, somente você saberá onde estão as coisas dentro de seu deste quarto, sendo muito mais trabalhoso para uma pessoa conseguir encontrar os itens dentro deste quarto. Se ele estivesse organizado com os itens em ordem alfabética, com as nomenclaturas corretas e descritivas, não precisaria abrir as gavetas e armários uma um para verificar se o item procurado esta em seu interior. Poupando tempo e localizando o item mais facilmente se fosse de um mesmo padrão.

É nesse ponto que o PEP 8 entra em ação. Nos códigos Python ele serve como um guia de escrita dos códigos, declaração de nomes das variáveis, classes, objetos e assim por diante. Para melhor entender e localizar os itens dentro do seu código.

O que o PEP 8 nos ensina?

Nomenclatura importante: Da mesma forma que você dá nomes aos seus objetos de diversão, o PEP 8 orienta a dar nomes significativos às nossas variáveis e funções.

 # Correto
nome = "João"
idade = 25
total_vendas = 1000

# Incorreto
n = "João"
i = 25
x = 1000

Estabelece orientações sobre a utilização adequada de espaços e tabulações a fim de otimizar a organização do código. É similar a organizar sua escrivaninha para que todos os itens se encaixem perfeitamente.

# Correto
def minha_funcao():
    if x == 5:
        print("x é igual a 5")

# Incorreto
def minha_funcao():
  if x == 5:
    print("x é igual a 5")

Frases breves facilitam a leitura, não é mesmo? Assim como o PEP 8 recomenda que mantenhamos nossas linhas de código com um tamanho adequado para facilitar a compreensão.

# Correto
resultado = (variavel1 + variavel2 +
             variavel3 + variavel3 +
             variavel4 + variavel5 +
             variavel6 + variavel7)

# Incorreto
resultado = (variavel1 + variavel2 + variavel3 + variavel4 + variavel5 + variavel6 + variavel7)

Comentários úteis são importantes, pois ajudam a melhorar a compreensão do código. Seguir as diretrizes do PEP 8 nos auxilia a criar comentários explicativos e que realmente acrescentam valor ao código.

# Correto
# Calcula a média de uma lista de números
def calcular_media(lista):
    total = sum(lista)
    return total / len(lista)

# Incorreto
# Função
def media(lista):
    # Soma
    total = sum(lista)
    # Média
    return total / len(lista)

Coerência: Você aprecia quando todas as suas peças de Lego possuem dimensões iguais? Da mesma maneira, o PEP 8 nos pede para sermos consistentes em como escrevemos nosso código.

 # Correto
valor_total = 1000
taxa_de_desconto = 0.1

# Incorreto
ValorTotal = 1000
Taxa_de_Desconto = 0.1

Existem Bibliotecas que nos auxiliam para aplicarmos o PEP 8 ao nosso código, que automatizam e tronam nossos códigos mais legíveis e dentro dos padrões do mercado sem muito esforço:

Flake8:

É um instrumento que examina seu código para garantir sua conformidade com o PEP 8 e outras normas de estilo. Ele examina seu código para encontrar questões importantes , como problemas de estilo ou erros de sintaxe. Combinando diversas ferramentas, como PyFlakes ,PyFlakes, PyCodestyle (o antigo Pep8) e McCabe, Estilo PyCodeFlake8 fornece uma análise de seu código.

pip install flake8

flake8 meu_codigo.py

Black:

O Black é um instrumento de formatação de código que, de acordo com conforme diretrizes do PEP 8, reformata seu código de forma automática. Isso significa que ele aplica um estilo consistente e predefinido ao seu código sem exigir configuração adicional . O Black tem a capacidade de ser integrado ao seu fluxo de trabalho, formatando o código de forma automaticamente cada vez que você salva ou envia para controle de versão.

pip install black

black meu_codigo.py

ISort:

ISort é uma ferramenta de classificação de importações que é organizada de forma consistente e legível como atualmente no topo de seus arquivos. Além das convenções do PEP 8, ele se reorganiza especificamente, agrupando em documentários e garantindo que sejam ordenadas alfabeticamente, visando manter a ordem e a legibilidade do seu código, o ISort pode ser benéfico para identificar e navegar pelas dependências do projeto.

pip install isort

isort meu_codigo.py

Essas ferramentas são amplamente utilizadas por toda a comunidade Python e podem ser integradas aos processos de desenvolvimento de softwares para garantir que o código esteja formatado, legível e compatível com as diretrizes do PEP8.

Isso ajudará a manter um estilo profissional e consistente em todos os projetos de desenvolvimento para garantir que o código esteja bem formatado, legível e em conformidade com as diretrizes PEP 8.

Vamos Disseminar os Conhecimentos e Transbordar Tudo o que Aprendemos!

Segue o Link do meu GitHub: Meu GitHub

Segue o Link do meu LinkedIn: Meu LinkedIn

Dicas Importantes para Quem está Iniciando na Área de Tecnologia:

Carlos Henrique Garcia Soares — Fri, 26 Apr 2024 12:25:42 +0000

Para você que está iniciado na área de tecnologia há diversas dúvidas a serem esclarecidas e sanadas, tentei lembrar quais foram minhas maiores dúvidas quando iniciei neste mundo, e cheguei em dois pontos principais que acredito que qualquer pessoa iniciando em tecnologia. Quando iniciei nesta área, comecei de forma errada, estudando C# e HTML, sem conhecer os fundamentos e bases necessárias, me sentindo perdido por diversas vezes durante meu aprendizado. Por isso fiz este artigo explicando os dois pontos que para mim foram seriam de grande valia quando iniciei meus estudos em 2016.

1 – O que devo estudar e por onde começar:
O primeiro item, sem sombra de dúvida é aprender logica de programação. Antes mesmo de decidir qual linguagem de programação quer seguir. Aprendendo lógica você vai saber como pegar um problema do cotidiano que algum cliente esteja passando e automatizar a solução destes problemas utilizando a logica de programação, sabendo desenhar e delimitar todo o problema de forma estruturada apontando para sua solução. E somente depois de terminar este passo é que nós Devs, desenvolvemos o código fonte de tal problema na linguagem de programação desejada e mais indicada para a situação desta demanda específica ou a que melhor você domina, afinal toda linguagem tem um vasto campo para solução de demandas.

Um bom exemplo que muito utilizam é como fazer um bolo. Para se fazer um bolo tem um passo a passo a ser seguido, e este passo a passo se torna a Lógica de Programação:

Passo1 - Pegar uma tigela;
Passo 2 – Colocar farinha, ovo, manteiga e leite;
Passo 3 - Bater a massa;
Passo 4 – Colocar no forno;
Passo 5 - Retirar do forno;

Com a lógica pronta, devemos focar em como conseguimos trazer essa Lógica para o nosso dia a dia, neste caso para fazer um bolo devemos utilizar uma panela, um forno, e não um carro ou uma escada. Esta analogia serve para sabermos qual a melhor linguagem de programação melhor se encaixa para resolver tal situação.

Após aprender a Lógica, devemos escolhe a Linguagem de Programação que mais lhe agrada ou que o mercado mais necessita. Porém sobre este fato prefiro optar pela primeira opção focando sua escolha na linguagem que mais lhe agrada, afinal o mercado possui espaço para todas linguagens, havendo softwares legados, novos projetos, etc, que podem ou utilizar linguagens de programação mais antigas e robustas que permanecem em uso até os dias atuais como o C# ou com linguagens de programação mais novos como Python.

2 – Como realmente me tornar bom em resolver os problemas do dia a dia utilizando tecnologia:
A maior dica para se tornar bom em algo que faz é se dedicar. Os autores que ensinam sobre treinamento e desenvolvimento, chegaram em um consenso que para você virar um expert em determinado assunto você deve ter 10.000 horas de prática sobre esse assunto. Não quero te assustar e dizer que você precisa investir tanto tempo assim de imediato, vamos começar devagar estudando Lógica de Programação, continuar estudando sua linguagem preferida e após ir praticando na resolução de desafios que há em diversos sites que servem para testar seus conhecimentos e até mesmo ranquear os devs em sua plataforma, te proporcionando visibilidade para o mercado de tecnologia, segue alguns sites para você se desafiar:

HackerRank: https://www.hackerrank.com/
Codewars: https://www.codewars.com/
Exercism: https://exercism.org/
Beecrowd: https://judge.beecrowd.com/pt/login
Edabit: https://edabit.com/
LeetCode: https://leetcode.com/

Vamos Disseminar os Conhecimentos e Transbordar Tudo o que Aprendemos!

Segue o Link do meu GitHub: https://github.com/Carlos-CGS

Segue o Link do meu LinkedIn: https://www.linkedin.com/in/carlos-cgs/

Documentário que todo Profissional de TI deve Ver: O Dilema da Redes (2020).

Carlos Henrique Garcia Soares — Mon, 22 Apr 2024 17:21:22 +0000

“Se você não está pagando o produto. Então você é o produto”
Atualmente são os anunciantes que pagam pelos aplicativos que você usa “de graça”, com isso os usuários deixam de comprar o produto “aplicativo” e os anunciantes adquirem o produto que somos todos nós.

Super indico este excelente documentário que explana de forma simples, porém bem completa tudo o que ocorre nos bastidores das BigTechs de pesquisa e mídias sociais como um todo ao redor do mundo. Elas buscam sempre manter os usuários mais tempo em suas plataformas. Com isso eles conseguem ter mais influência na vida de cada usuário e manipular determinada parcela da população mundial. Seguindo um estudo psicológico do cérebro humano, os desenvolvedores criam algoritmos que fomentem a liberação de dopamina e prazeres momentâneos nos usuários seguindo alguns passos:

“Existem apenas duas indústrias que chamam seus clientes de usuários a de drogas e a de software”

Primeiro começa com a análise de tudo o que você vê ou usa em seus eletrônicos, desde o tempo em segundos em que você fica vendo uma foto, uma postagem até o tempo jogando algum tipo de jogo ou aplicativo.
O segundo passo é começar a te bombardear apenas o que faz parte do seu grupo de interesse baseado em suas informações de uso destes softwares. Neste ponto, os programadores não possuem mais domínio total sobre o que lhe será sugerido, pois é feita uma análise algorítmica de probabilidades de conteúdo do seu interesse feita somente através dos códigos que verificam seu histórico e projetam o que você irá desejar em um próximo feed ou conteúdo sugerido. Neste momento que eles vendem esses espaços para propagandas de seu interesse e monetizando entre os conteúdos. Uma grave observação é que esses algoritmos não fazem qualquer julgamento sobre o conteúdo ser prejudicial ou não para o usuário, apenas segue sua principal instrução que é buscar a forma de mate-lo mais tempo o utilizando.
O terceiro passo é a desinformação em massa, ou em outras palavras, fazer com que determinado grupo de pessoas acreditem em uma verdade fomentada pelas indicações de conteúdos feitas pelas redes sociais. Dentro desses grupos, que pensam da mesma forma que você, o usuário acredita que o mundo é conforme ele imagina na sob a sua perspectiva, afinal só tem contato com conteúdo e pessoas que tem os mesmos interesses que ele. Se limitando a pensamentos antagônicos que os façam questionar e refletir sobre a veracidade sobre determinado assunto.
Para concluir, esses três primeiros pontos criam uma nação ou um mundo dividido entre duas vertentes. A e B ou Direita e Esquerda, criando um discurso de ódio entre eles que se fortalece com os direcionamentos de conteúdos que defendem a linha de pensamento de cada usuário. Sob esta perspectiva, esses algoritmos podem ter feito facilmente um direcionamento de conteúdo que incitou massas para seguir esse viés de ódio, criando uma rincha entre os dois grupos. Podendo até mesmo direcionar este conflito para uma provável guerra civil em algumas nações que não consigam perceber a manipulação das BigTechs, através dos conteúdos direcionados e com isso esse algoritmo de probabilidade também podendo ser definido como “inteligência Artificial” poderá quebrar uma nação, através de algo que no início parecia inofensivo como um direcionamento de conteúdo, mas na verdade altera o ser humano por dentro, manipulando o seu ego.

Segue imagem que vinha de fábrica escondida dentro dos smartphones antigos quando foi lançado o sistema android:

Porém não vamos nos apavorar, esta é apenas um reflexão que todos devem fazer sobre o lado negativo da tecnologia. Porém há diversos pontos positivos que sobressaem em meio estas perspectivas sombrias, como você conseguir chamar um carro de aplicativo em menos de cinco minutos ele já estar em sua porta de casa, conectar com pessoas que antigamente seria praticamente impossível, comunicação instantânea e até mesmo a facilidade do ensino que agrega as tecnologias para vencer o distanciamento físico, e tantos outros avanços tecnológicos.

Vamos Disseminar os Conhecimentos e Transbordar Tudo o que Aprendemos!

Segue o Link do meu GitHub: https://github.com/Carlos-CGS

Segue o Link do meu LinkedIn: https://www.linkedin.com/in/carlos-cgs/

Como Fazer um Validador de CPF com Python de forma simples e refatorada!

Carlos Henrique Garcia Soares — Fri, 19 Apr 2024 13:03:06 +0000

CPF ou Cadastro de Pessoa Fisica é um documento com numeração única que pertence a uma pessoa para sempre. Ele é composto de nove dígitos iniciais, mais dois dígitos verificadores, totalizando onze dígitos.

A validação do CPF baseia-se na análise dos nove primeiros dígitos em comparação com os dois últimos dígitos verificadores, sendo assim esta verificação é feita em duas partes, cada um com suas devidas particularidades.

- Primeira Validação:
Multiplicamos os nove primeiros dígitos do CPF pelos valores de 10 a 2.
Se a soma desses produtos dividida por 11 resultar em um resto menor ou igual a 1, o penúltimo dígito do CPF deve ser zero.
Se o resto for maior que 2, o penúltimo dígito do CPF deve ser 11 menos o resto.

- Segunda Validação:
Repetimos o processo, começando a multiplicação pelo número 11.
Adicionamos o primeiro dígito verificador na soma.
Verificamos novamente as regras para o último dígito do CPF.

Abaixo, um código que foi elaborado de forma explicativa e simples, sem a utilização de bibliotecas, para facilitar a compreensão, mesmo para aqueles que não conhecem a linguagem Python.

# Criado abaixo uma função para validar um CPF digitado.
NOVO_CPF = list(input("Digite um CPF para ser validado >>>"))
NOVO_CPF_STRING = " ".join(NOVO_CPF)

def validacao_cpf():
    if len(NOVO_CPF) == 11:
        primeiro1 = int(NOVO_CPF[0]) * 10
        primeiro2 = int(NOVO_CPF[1]) * 9
        primeiro3 = int(NOVO_CPF[2]) * 8
        primeiro4 = int(NOVO_CPF[3]) * 7
        primeiro5 = int(NOVO_CPF[4]) * 6
        primeiro6 = int(NOVO_CPF[5]) * 5
        primeiro7 = int(NOVO_CPF[6]) * 4
        primeiro8 = int(NOVO_CPF[7]) * 3
        primeiro9 = int(NOVO_CPF[8]) * 2

        seg_primeiro1 = int(NOVO_CPF[0]) * 11
        seg_primeiro2 = int(NOVO_CPF[1]) * 10
        seg_primeiro3 = int(NOVO_CPF[2]) * 9
        seg_primeiro4 = int(NOVO_CPF[3]) * 8
        seg_primeiro5 = int(NOVO_CPF[4]) * 7
        seg_primeiro6 = int(NOVO_CPF[5]) * 6
        seg_primeiro7 = int(NOVO_CPF[6]) * 5
        seg_primeiro8 = int(NOVO_CPF[7]) * 4
        seg_primeiro9 = int(NOVO_CPF[8]) * 3
        seg_primeiro10 = int(NOVO_CPF[9]) * 2

        soma_validacao = (primeiro1 + primeiro2 + primeiro3 + primeiro4 + primeiro5 + primeiro6 + primeiro7 + primeiro8 + primeiro9)
        divisao_soma = (soma_validacao // 11)
        resto = (soma_validacao - (11 * divisao_soma))

        soma_validacao_2 = (seg_primeiro1 + seg_primeiro2 + seg_primeiro3 + seg_primeiro4 + seg_primeiro5 + seg_primeiro6 + seg_primeiro7 + seg_primeiro8 + seg_primeiro9 + seg_primeiro10)
        divisao_soma_2 = (soma_validacao_2 // 11)
        resto_2 = (soma_validacao_2 - (11 * divisao_soma_2))

        antepenultimo_digito_cpf = int(NOVO_CPF[8])
        penultimo_digito_cpf = int(NOVO_CPF[9])
        ultimo_digito_cpf = int(NOVO_CPF[10])

        val_1 = False
        val_2 = False
        val_3 = False
        val_4 = False

        if(resto <=1) and (penultimo_digito_cpf == 0):
            val_1 = True
        if( resto >=2 and resto < 10) and (11 - resto == penultimo_digito_cpf):
            val_2 = True
        if( resto_2 <=1 ) and (ultimo_digito_cpf == 0):
            val_3 = True
        if ( resto_2 >=2 and resto_2 < 10 ) and (11 - resto_2 == ultimo_digito_cpf):
            val_4 = True
        else: ()

        if (val_1 == True or val_2 == True) and (val_3 == True or val_4 == True):
            print(f"O CPF número: {NOVO_CPF_STRING} é válido !")
        else:
            print(f"O CPF número: {NOVO_CPF_STRING} é inválido, tente novamente.")

        #Abaixo Validação dos estado de origem do CPF
        if antepenultimo_digito_cpf == 1:
            print("Seu CPF é originário do estado do Distrito Federal, Goiás, Mato Grosso do Sul ou Tocantins")
        elif antepenultimo_digito_cpf == 2:
            print("Seu CPF é originário do estado do Pará, Amazonas, Acre, Amapá, Rondônia ou Roraima")
        elif antepenultimo_digito_cpf == 3:
            print("Seu CPF é originário do estado do Ceará, Maranhão ou Piauí")
        elif antepenultimo_digito_cpf == 4:
            print("Seu CPF é originário do estado de Pernambuco, Rio Grande do Norte, Paraíba ou Alagoas")
        elif antepenultimo_digito_cpf == 5:
            print("Seu CPF é originário do estado da Bahia; e Sergipe")
        elif antepenultimo_digito_cpf == 6:
            print("Seu CPF é originário de Minas Gerais")
        elif antepenultimo_digito_cpf == 7:
            print("Seu CPF é originário do estado do Rio de Janeiro ou Espírito Santo")
        elif antepenultimo_digito_cpf == 8:
            print("Seu CPF é originário do estado de São Paulo")
        elif antepenultimo_digito_cpf == 9:
            print("Seu CPF é originário do estado do Paraná ou Santa Catarina")
        else:
            print("Seu CPF é de origem do estado do Rio Grande do Sul")

    else: 
        print(f"O CPF número: {NOVO_CPF_STRING} é inválido, tente novamente.")

validacao_cpf()

Abaixo, eu reescrevi o código, refatorando-o para torna-lo mais legível e fácil de entender, utilizando alguns artifícios da biblioteca re, possibilitando maior facilidade para manutenções futuras, deixando o código menor e mais enxuto.

import re

def validador():
    cpf = input("Digite um CPF para ser validado ao lado. >>>")

    # Retira apenas os dígitos do CPF, ignorando os caracteres especiais
    numeros = [int(digito) for digito in cpf if digito.isdigit()]

    formatacao = False
    quant_digitos = False
    validacao1 = False
    validacao2 = False

    # Verifica a estrutura do CPF (111.222.333-44) ou (11122233344)
    if re.match(r'\d{3}\.\d{3}\.\d{3}-\d{2}', cpf) or re.match(r'\d{11}', cpf):
        formatacao = True

    if len(numeros) == 11:
        quant_digitos = True

        soma_produtos = sum(a * b for a, b in zip(numeros[0:9], range(10, 1, -1)))
        digito_esperado = (soma_produtos * 10 % 11) % 10
        if numeros[9] == digito_esperado:
            validacao1 = True

        soma_produtos1 = sum(a * b for a, b in zip(numeros[0:10], range(11, 1, -1)))
        digito_esperado1 = (soma_produtos1 * 10 % 11) % 10
        if numeros[10] == digito_esperado1:
            validacao2 = True

        if quant_digitos and formatacao and validacao1 and validacao2:
            print(f"O CPF {cpf} é válido.")
        else:
            print(f"O CPF {cpf} não é válido... Tente outro CPF...")

        # Verificação dos estados de origem do CPF
        estado_origem = numeros[8]
        estados = {
            1: "Distrito Federal, Goiás, Mato Grosso do Sul ou Tocantins",
            2: "Pará, Amazonas, Acre, Amapá, Rondônia ou Roraima",
            3: "Ceará, Maranhão ou Piauí",
            4: "Pernambuco, Rio Grande do Norte, Paraíba ou Alagoas",
            5: "Bahia ou Sergipe",
            6: "Minas Gerais",
            7: "Rio de Janeiro ou Espírito Santo",
            8: "São Paulo",
            9: "Paraná ou Santa Catarina"
        }
        if estado_origem in estados:
            print(f"Seu CPF é originário do estado de {estados[estado_origem]}.")
        else:
            print("Seu CPF é de origem do estado do Rio Grande do Sul")

    else:
        print(f"O CPF {cpf} não é válido... Tente outro CPF...")

validador()

Vamos Disseminar os Conhecimentos e Transbordar Tudo o que Aprendemos!

Segue o Link do meu GitHub com o código Simples: Meu GitHUb

Segue o Link do meu GitHub com o código Refatorado: Códigos

Segue o Link do meu LinkedIn: Meu LinkedIn