Neste vídeo, você vai aprender tudo sobre os cartuchos HiROM de SNES e como eles funcionam. Voltado para programadores e desenvolvedores de jogos para SNES, o vídeo vai desvendar os segredos do hardware desses cartuchos.

Neste episódio vamos continuar de onde paramos no episódio anterior e vamos ver como funciona um cartucho HiRom que tem save, e para isso utilizaremos o jogo Chrono Trigger como exemplo.

Neste vídeo, você vai aprender tudo sobre os cartuchos HiROM de SNES e como eles funcionam. Voltado para programadores e desenvolvedores de jogos para SNES, o vídeo vai desvendar os segredos do hardware desses cartuchos.

Neste episódio vamos aprender sobre o modo de endereçamento absoluto da cpu 65c816 do Snes.

Neste video mostro como configurar o Vim e o Neovim para programação em Python. Mostro como instalar um linter e fixer para adicionar várias funcionalidades para programação em Python.

Neste episódio vamos aprender sobre o modo de endereçamento absoluto CURTO da cpu 68000 do Mega Drive.

Neste episódio vamos aprender sobre o modo de endereçamento absoluto da cpu 65c816 do Snes.

Neste episódio vamos criar um projeto do zero em Rust e aprender alguns elementos fundamentais da linguagem.

Neste episódio vamos aprender sobre o modo de endereçamento absoluto da cpu 68000 do Mega Drive.

Neste episódio vamos aprender sobre o modo de endereçamento absoluto da cpu 68000 do Mega Drive.

Neste episódio vamos ver um dos conceitos mais importantes para quem está aprendendo a linguagem RUST. O conceito de Ownership e Borrow.

Neste episódio eu falo como foi fazer o curso de engenharia de computação na Unicamp, falando um pouco sobre as matérias e como foi minha trajetória nesta universidade até me tornar um programador.

Neste episódio vamos fazer um desafio envolvendo QRCode e XOR.

Em programação é comum vermos o termo Sign Extension quando trabalhamos com código mais baixo nível, e muitas pessoas acabam não entendendo de fato o que acontece quando ocorre a extensão de sinal.

Neste episódio vamos começar a aprender mais a fundo os modos de endereçamento disponíveis no Snes e no Mega Drive.

Neste episódio vamos implementar um algoritmo simples em assembly de Snes. Vamos criar uma lista de números aleatórios e vamos varrer esta lista tentando encontrar um número passado como parâmetro.

Neste episódio mostro como fazer um loop for em assembly de Mega Drive. Mostro como implementar o loop for usando instruções mais comuns que existem em todas as Cpus e também mostro como utilizar algumas instruções mais dedicadas para loops que existem na Cpu 68000 da Motorola.

Neste vídeo eu faço um mini projeto de programar um pêndulo duplo. O pêndulo duplo tem uma física bem complexa por trás e possui um movimento caótico muito interessante.

Neste episódio eu mostro como implementar um loop while em assembly. Faço o código usando assembly de Snes e mostro algumas variações possíveis desse loop e comparo com o loop for.

Neste episódio eu mostro como implementar um if/else em assembly. Para isso vamos aprender as instruções condicionais de branching.

Neste episódio falo sobre as instruções de comparação, que estão entre as mais importantes pra entender programação assembly.

Neste episódio começo a parte de branching em assembly. É com esse tipo de instrução que conseguimos fazer if, else, for, while, rotinas, etc.

Quem é fã de Chrono Trigger e já jogou o game deve lembrar da introdução onde aparece um pêndulo na tela com um efeito muito legal. Pois bem, em homenagem a esta introdução clássica eu vou implementar neste vídeo um pêndulo e mostrar toda a física envolvida.

Neste episódio vou mostrar o ambiente de programação que usaremos em 2022 nesta série de vídeos sobre SNES e MEGA DRIVE. Estou renomeando esta série para Retro Level Programming.

Neste video mostro como configurar o Vim e o Neovim para programação em C/C++. Mostro como instalar um linter e fixer para adicionar várias funcionalidades para programação nessas linguagens.

Neste video mostro como configurar o Vim e o Neovim do zero, preparando toda a estrutura.

Neste episódio vou explicar o que é Overflow em programação, tanto com sinal (signed), como sem sinal (unsigned).

Nesta parte da série vou falar um pouco sobre o tamanho dos dados nos modos 8 bits e 16 bits, e o possíveis problemas que podem ocorrer na hora da geração do código.

Neste vídeo mostro que o Snes tem suporte a modos 8 bits e 16 bits e é comum ficar alternando entre esses modos a todo momento. Quando a Cpu está em modo 8 bits as instruções passam a trabalhar com dados de 8 bits. O mesmo vale para o modo 16 bits. No vídeo explico todas as opções.

Neste vídeo mostro como instalar e configurar o Windows Terminal. O Windows Terminal é uma das melhores escolhas de terminal no Windows, se não for a melhor. Com ele é possível criar várias abas e várias janelas (panes) dentro de uma aba.

Neste vídeo eu explico sobre Big Endian e Little Endian mostrando exemplos de código no Snes e no Mega Drive. O conceito de endianess sempre aparece em computação, principalmente quando estamos manipulando dados. Nos casos dos consoles antigos o Snes é Little Endian e o Mega Drive é Big Endian.

Neste vídeo eu mostro como implementar colisão em jogos, usando como exemplo a engine de Raycasting que estou fazendo.

Neste episódio mostro como é possível realizar operações de 64bits com o Mega Drive.

Dado um array ordenado de números (positivo e negativos), temos que criar um array do mesmo tamanho que contenha todos os números do array de entrada elevados ao quadrado. O detalhe principal é que este array com os elementos ao quadrado também deve estar ordenado.

Neste vídeo eu falo sobre Random Walk, que nada mais é do que fazer um pixel ficar andando na tela de forma aleatória.

O algoritmo deste vídeo se trata de descobrir se um array é monotônico. Um array é monotônico se ele for não decrescente ou não crescente.

Neste episódio eu falo sobre algumas das instruções aritméticas do Snes, como soma, subtração, incremento e decremento.

Neste episódio eu explico as instruções aritméticas da cpu Motorola 68000 do Mega Drive. Falo principalmente das instruções de soma (add) e subtração (sub).

Neste vídeo eu mostro como alterar a sintaxe da linguagem Python. Para isso mostro como alterar a gramática do interpretador Cpython, adicionando mais uma opção à operação "pass".

Neste vídeo começo a falar sobre as instruções do Snes, inicialmente nas instruções de movimentação de dados, fazendo uma comparação com as instruções do Mega Drive.

Neste vídeo eu mostro dois algoritmos para desenhar círculos do zero. Basicamente existem dois grupos de algoritmos para desenhar uma forma geométrica, um pintando pixels e outro desenhando linhas entre pontos.

Neste episódio eu continuo falando sobre as instruções da família Move no Mega Drive. Resolvi listar todas as instruções e dividir em grupos de instruções similares.

Neste vídeo eu faço um mini projeto de implementação de fractais usando os Sistemas-L, ou L-Sistems.

Neste vídeo eu mostro como compilar o interpretador do python, o CPython, para estudarmos a fundo a linguagem Python.

Neste episódio começamos a aprender as instruções do console Mega Drive, iniciando com a instrução MOVE, que é uma das instruções mais, se não a mais, utilizadas em assembly.

Neste vídeo eu explico o que é e como implementar a cifra de César. Este é um algoritmo muito simples para a criptografia de uma mensagem de texto.

Neste episódio começo a falar sobre colisão em jogos, e mostro como NÃO fazer as colisões.

O Project Euler é um site fantástico para treinar programação e desenvolver suas habilidades de resolução de problemas.

Neste vídeo eu mostro como compilar o emulador de Mega Drive Genesis Plus GX. Este é um dos melhores emuladores de Mega Drive e o código é muito fácil de entender.

Neste episódio eu dou uma introdução a editores hexadecimais mostrando como usar um editor hexadecimal e o que cada parte de um editor hexadecimal significa.

Neste vídeo eu mostro como instalar a extensão do Github Copilot no Vscode e como entrar na lista de espera do projeto.

Olhem para a placa deste jogo e tentem encontrar o que há de estranho nele? Este é um dos jogos bizarros de Snes.

No problema do vídeo o desafio é encontrar os três maiores números em um array de números. O array contém números positivos e negativos e não necessariamente está ordenado.

Neste vídeo dou uma introdução à Teoria dos Grafos, falando sobre vários assuntos relacionados a grafos.

Neste episódio falo sobre escopo de variáveis em Javascript. Esta é uma introdução ao assunto pois o objetivo é chegarmos em Closures, que é um conceito muito importante em Javascript.

O problema explicado neste vídeo é o de gerar um número aleatório usando uma moeda.

Neste episódio mostro como fazer a engine de raycasting ficar em tela cheia.

Neste problema de programação temos um array de números (positivos e negativos) e o objetivo é, dado um segundo array, verificar se este segundo array é uma subsequência do primeiro array.

Neste episódio eu começo a entrar no assunto de programação em assembly introduzindo mais informações sobre instruções, modos de endereçamento e sobre o esquema geral de como programação em assembly funciona.

Neste vídeo mostro como adicionar fading em músicas usando Python. Fading é o efeito que faz a música diminuir de volume no final, para terminar de forma suave.

Neste episódio eu adiciono controles na engine de Raycasting. Para isso uso a Api de Gamepad dos Browsers para pegar os dados dos controles.

Neste episódio eu explico o mapa de memória do Snes. O mapa de memória do Snes é um pouco mais complexo que o do Mega Drive devido ao fato da Cpu do Snes trabalhar com bancos.

Neste episódio eu adiciono na engine de raycasting a intensidade dos controles.

Neste algoritmo o objetivo é verificar se um array de números contém um ciclo único.

Neste episódio mostro como capturar o mouse em uma aplicação web com canvas. Isso é fundamental em jogos 3D pois a aplicação tem que ter controle do mouse para conseguirmos girar o personagem de forma contínua.

Neste episódio eu explico sobre o que são Mirrors de memória. Mirror ocorre quando temos mais de um range de endereços que apontam para a mesma memória. Então podemos acessar uma certa memória usando mais de um endereço.

Neste vídeo eu mostro como adicionar o mouse na engine de raycasting que estamos implementando. Esta adição é extremamente simples pois já temos uma classe de input que retorna comandos, e já temos os comandos de rotação.

Neste vídeo eu falo sobre o mapa de memória do mega drive, dando uma introdução em todas as regiões da memória do console.

Neste vídeo eu mostro como acessar a Api de controles no browser usando Javascript puro. Mostro como facilmente acessar os eixos e botões em um controle de Xbox 360.

Neste vídeo eu mostro como instalar várias versões do compilador de C/C++ CLANG no Windows 10 e como facilmente alterar entre as versões quando necessário.

Neste episódio eu mostro como considerar o framerate (fps) no código dos jogos. O principal conceito é sempre atualizar o mundo considerando o tempo entre os frames.

Neste episódio eu começo a falar sobre mapa de memória em programação. Isso aparece sempre que vamos programar em consoles antigos ou mesmo muitas placas de hoje em dia.

Neste episódio eu mostro como implementado o Strafe em jogos, que é o movimento de andar para os lados. O termo vem de Metralhar, onde o objetivo é circular um inimigo e ficar atirando nele.

Neste vídeo eu mostro como converter músicas em Python. Eu explico como converter mp3 para wav e wav para mp3. A biblioteca usada para isso é a PyDub, que permite uma manipulação muito grande de áudios.

Neste episódio eu mostro como fazer a rotação do personagem na engine de raycasting. O procedimento é muito similar ao vídeo anterior onde andamos pra frente e para trás.

Neste episódio eu explico sobre os bancos de memória no Snes. Os bancos de memória possuem 64KiB de tamanho, e existem 256 bancos no Snes, indo do banco 0x00 até o banco 0xff.

Neste episódio mostro como fazer os movimentos de ir pra frente e para trás na engine de raycasting.

Neste vídeo falo sobre matriz de rotação, que é muito usado em programação para rotacionar coisas.

Neste episódio eu falo começo uma introdução dos registradores do Snes. Isso é fundamental para programar pra Snes. A cpu do Snes é bem diferente do Mega Drive em relação a registradores.

Neste episódio mostro como realizei algumas alterações no emulador Bsnes Plus. Neste quarto vídeo eu mostro as alterações relativas ao foco das janelas.

Neste vídeo mostro 5 livros que considero entre os melhores para treinar programação, algoritmos e se preparar para entrevistas técnicas de programação.

Neste vídeo mostro um efeito interessante de Python. Tuplas são imutáveis em Python, então Python não permite a alteração de elementos em uma tupla. Porém ao fazermos uma modificação in place em uma lista dentro de uma tupla, a alteração é feita.

Neste episódio eu começo a inserir a parte de Input na nossa engine de Raycasting.

Neste episódio eu mostro como manipular os eventos do teclado e tratar no código a entrada dos comandos. O que eu mostro no vídeo serve para qualquer linguagem e framework, onde a estrutura é no fundo a mesma.

Neste vídeo eu reúno os 5 melhores sites que eu conheço para treinar programação e algoritmos. Muitas empresas fazem entrevistas técnicas na hora de contratar um programador, por isso é necessário sempre estar treinando, nem que for apenas para conhecer minimamente as principais questões que podem aparecer em entrevistas para várias tipos de vagas de emprego.

Neste vídeo eu mostro as diferenças entre as formas de somar coisas em python usando o=+". No vídeo eu mostro que a soma usando o=" e o "+" separados gera um novo objeto. Devido a esse comportamento o Python tem métodos mágicos diferentes para cada caso, sendo o "__add__" para somas normair e o "__iadd__" para somas in place. Esse comportamento é importante dependendo do que você estiver fazendo, ...

Neste vídeo mostro como realizei algumas alterações no emulador Bsnes Plus. Neste terceiro episódio eu mostro como ativar o auto-update das janelas no início do emulador.

Em Python podemos multiplicar uma lista por um número, e o Python replica os elementos internos da lista para ficar com o número desejado. O problema disso é que se a lista tiver outras listas ou objetos, apenas as referências são copiadas.

Neste vídeo mostro mais um problema muito comum em entrevistas técnicas de computação. Dado um array de números inteiros, positivos e negativos, e um número alvo, o problema é procurar no array por dois números cuja soma é o número alvo informado.

Slices são usados a todo momento em Python para acessar partes de uma lista ou qualquer iterável. O detalhe legal é que Python permite o uso de slices no lado esquerdo de uma atribuição.

Neste vídeo mostro como realizei algumas alterações no emulador Bsnes Plus. Nesta segunda parte eu mostro como agrupar todas as janelas da parte de vídeo um apenas uma única janela com tabs.

Neste episódio eu falo sobre os registradores do Mega Drive, principalmente os registradores da Cpu 68000. É muito importante conhecer todos os registradores da arquitetura que vamos trabalhar.

Em Python quando definimos um range ou um slice, o último elemento é sempre excluído do intervalo gerado. Por que a linguagem Python trabalha desta forma?

Neste vídeo mostro como realizei algumas alterações no emulador Bsnes Plus. Esse emulador é usado como debugger em uma playlist de Assembly de Snes e Mega Drive que eu tenho aqui no canal. Eu fiz algumas modificações neste debugger para agilizar o processo de desenvolvimento. A primeira mudança que mostro nesse vídeo é como fiz para que o emulador já inicie com as janelas do debugger ativa. Com is...

Neste vídeo eu mostro como fazer uma imagem ficar preto e branco com código. Eu mostro um algoritmo que transforma a imagem em preto e branca de forma bem simples.

Neste vídeo eu mostro como criar texturas usado o Perlin Noise 2D. O Perlin Noise é um algoritmo muito conhecido para gerar números aleatórios, e o Perlin Noise 2D gera números em duas dimensões. Com esse algoritmo é possível criar muitas coisas interessantes, desde texturas até mapas pra jogos. No vídeo eu programo em Javascript usando o P5.js, e o P5 já possui suporte ao Perlin Noise 2D. É só ch...

Neste vídeo falo um pouco sobre registradores e alguns tipos de registradores que iremos trabalhar quando programamos para esses consoles antigos.

Neste vídeo eu explico a razão de usarmos logaritmos na prática. Os logaritmos servem para simplificar a nossa vida, mas em que situações eles simplificam?

Neste vídeo eu mostro como manipular pixels de forma rápida. Isso é possível tendo em mãos um array de bytes contendo os pixels.

Neste vídeo eu introduzo o assembler que usaremos para gerar as Roms que fizermos nesta série de vídeos. O assembler que eu utilizarei é o Bass. O Bass suporta assembly de Snes, de Mega Drive e de vários outros consoles.

Neste vídeo eu faço uma refatoração geral no código, criando uma classe específica para o Raycasting. Esta classe é a responsável por geral os frames que iremos adicionar no canvas.

Neste vídeo eu explico sobre a organização interna de uma ROM de Snes e Mega Drive e as diferenças entre um jogo desses consoles antigos com um jogo de computador ou consoles mais modernos.

Neste vídeo eu adicionei um código que faz o personagem se movimentar no mapa, como se fosse um Bot. Pra fazer este movimento eu uso Perlin Noise, que é muito útil pra criar caminhos aleatórios.

Finalmente neste vídeo as paredes vão aparecer na tela. Neste vídeo eu coloco no código o código que desenha a linha vertical para cada coluna, usando tudo o que vimos no vídeo passado.

Neste vídeo mostro como calcular o tamanho das linhas que desenharemos na tela para finalmente criar o efeito do Raycasting. Temos que desenhar as linhas no meio do canvas, então com a distância perpendicular que calculamos nos vídeos anteriores isso agora é possível.

Olá pessoal, neste vídeo falo um pouco de como foi o resultado do meu canal em 2020. Eu criei o canal em fevereiro e postei 149 vídeos durante o ano. Com esses vídeos consegui cerca de 670 inscritos. Agradeço do fundo do coração a todos que se inscreveram. Em 2021 a meta é de 2000 inscritos.

Neste vídeo falo sobre a questão do infinito que ocorre quando dividimos um número por zero. Isso ocorre no código no momento em que calculamos os deltas.

Neste vídeo mostro uma otimização no cálculo dos deltas no código. No algoritmo DDA, o que importa é a proporção entre os deltas, então podemos simplificar a fórmula dos deltas multiplicando ambos os deltas um um número específico que simplifica a forma.

Neste vídeo eu coloco no código as fórmulas de distância que finalizei no vídeo passado. O projeto está bem próximo de mostrar as paredes na tela.

Neste vídeo falo sobre as 5 principais linguagens de programação que eu focarei em 2021. Os meus critérios de escolha são tanto a parte prática no dia a dia do trabalho, como também no aspecto de nos tornarmos programadores melhores, o que é fundamental para todo programador de sucesso.

Neste vídeo falo sobre um problema comum na engine de Raycasting que é o efeito de olho de peixe, onde as parede ficam com um formato arredondado. Para corrigir esse problema é necessário modificar um pouco as fórmulas anteriores para calcular o que chamo de distância perpendicular.

Neste vídeo mostro a fórmula da distância euclidiana para os raios que batem nas faces verticais dos quadrados do mapa. No final mostro as duas fórmulas para a distância euclidiana, pro X e pro Y.

Neste vídeo mostro como compilar o emulador e debugger Exodus. No vídeo passado eu falei sobre o Exodus e no vídeo de hoje ensino como compilar o emulador para tornar possível a customização do debugger futuramente.

Neste vídeo mostro como calcular as fórmulas quando o raio bate em uma face horizontal da parede. Neste caso a váriável "hitSide" fica com o valor 1 após o loop do algoritmo DDA.

Esta é a parte 23 do curso de assembly com Snes e Mega Drive. Neste vídeo falo sobre o debugger que iremos usar para o Mega Drive e mostro como baixar e usar este emulador. No repositório do github do canal já deixei um pacote pronto compilado.

Neste vídeo mostro como calcular a distância do personagem até a parede, o que chamo de distância euclidiana. Essa distância pode ser encontrada com alguns cálculos simples, utilizando o resultado do algoritmo DDA explicado nos vídeos anteriores.

Neste vídeo eu codifico o algoritmo dda que expliquei nos vídeos anteriores. No final deste algoritmo nós conseguimos a informação de qual quadrado do mapa está a parede que o raio bateu.

Neste vídeo eu faço uma correção no código relativo ao cálculo dos Deltas. Ficou faltando tirar o valor absoluto da expressão, pois estamos interessados apenas na magnitude dos deltas, portanto o resultado tem sempre que ser positivo.

Neste vídeo mostro como compilar o Bsnes-Plus no Windows. Com o código do debugger conseguimos fazer alterações bem mais avançadas para nos ajudar nas seções de debug.

Neste problema temos dois arrays de números e o objetivo é escolher um número em cada array de tal forma que a diferença entre eles seja a menor possível.

Neste vídeo continuo de onde parei no vídeo anterior, dando mais exemplos e explicando mais alguns detalhes do algoritmo DDA.

Neste vídeo eu mostro como compilar o código do debugger baseado no Bsnes v086, que já mostrei em vídeos passados.

Neste vídeo começo a falar sobre o algoritmo DDA que já vinha citando em vídeos passados. Esta é a parte central do projeto, onde calculamos a distância do personagem até a parede mais próxima para cada raio. O algoritmo DDA nos dá, entre outras coisas, o quadrado do mapa onde está a parede que o raio bate.

Neste vídeo eu mostro como instalar várias versões do compilador de C/C++ MinGW no Windows 10 e como facilmente alterar entre as versões quando necessário.

Neste vídeo eu mostro uma outra opção de debugger que usaremos, o Bsnes Plus. Essa versão é baseada na versão v073 do Bsnes e atualmente é o melhor debugger de Snes na minha opinião.

Neste vídeo eu adiciono no código as distâncias que calculamos nos vídeos anteriores. Com essas distâncias já é possível começar aquele algoritmo DDA, que calcula a distância do personagem à parede mais próxima para cada raio.

Neste vídeo eu continuo calculando as últimas distâncias que faltavam para implementarmos o algoritmo DDA, que calcula a distância do personagem à parede mais próxima para cada raio.

Neste vídeo mostro como montar o ambiente de programação para o Snes, mais especificamente o debugger. Eu utilizo um debugger baseado na versão v086 do Bsnes.

Neste vídeo mostro como calcular a distância do jogador à borda do quadrado mais próximo para o raio atual. Essa distância (distToSideX) era a distância que faltava para conseguirmos iniciar o algoritmo DDA. Neste vídeo mostro apenas a parte matemática.

Neste vídeo mostro como criar um sistema de partículas muito simples usando Javascript. Um sistema de partículas é um conjunto de objetos que estão sob influência das leis da física, ou quaisquer outras leis, e são atualizados para refletir as condições do ambiente em que se encontram.

Nesta parte do projeto da engine de raycasting, mostro como calcular o quadrado do mapa em que o personagem se encontra. É um cálculo extremamente simples.

Este vídeo é um adendo aos vídeos sobre Cpu que eu tinha feito, explicando sobre Pipeline e Microcódigo.

Dado um array de números, temos que criar uma função que recebe o array e um número qualquer do array. Temos então que modificar o array para todas as ocorrências desse número em questão fiquem no final do array.

Neste vídeo continuo falando sobre como uma Cpu funciona e falo sobre as instruções "jump" e "branch". Essas instruções servem para alterar o fluxo das instruções, pulando para outro endereço para executar as próximos instruções a partir deste endereço.

Neste vídeo eu adiciono no código os deltas que foram calculados no vídeo anterior.

Como fazer contas com números gigantes em JavaScript? BigInt é a resposta. Com BigInts podemos trabalhar com números inteiros gigantes, facilitando muito vários tipos de cálculos.

Nesta parte 10 eu mostro como calcular os deltas dos raios do raycasting. O resultado é bem interessante.

Neste vídeo eu introduzo quais elementos geométricos vamos ter que calcular para realizar o algoritmo DDA, que é o que calcula as distâncias percorridas pelos raios.

Neste vídeo eu continuo a sequência onde estou explicando como uma Cpu funciona internamente, e adiciono no circuito os componentes necessários para fazer a instrução "move".

Neste vídeo falo sobre números em Javascript. Falo sobre o formato Ieee 754 e dou vários detalhes sobre como os números funcionam em Javascript.

Neste vídeo começo a falar sobre o algoritmo DDA, que é o principal algoritmo desta engine, sendo o responsável pelo cálculo da distância do raio entre o personagem e a parede mais próxima.

Neste vídeo continuo a sequência onde estou projetando uma Cpu simples para explicar como uma Cpu funciona. Isso vai nos ajudar a entender as instruções assembly que iremos começar a trabalhar nos próximos vídeos.

Neste vídeo eu resolvo um problema de programação que é verificar se existe um palíndromo em alguma permutação de uma string.

Neste vídeo começo a montar uma Cpu básica usando os componentes que expliquei nos vídeos anteriores. Nesta parte eu foco primariamente em como a Cpu pega as instruções da memória, então falo sobre o registrador Program Counter e como essa essa lógica é feita nos barramentos e memórias.

Neste vídeo eu falo um pouco mais sobre Cpus, mostrando os principais elementos internos de uma Cpu.

Neste vídeo eu explico sobre o loop principal da engine e adiciono no código o loop que vai calcular os raios e fazer os desenhos na tela.

Neste vídeo falo sobre a Unidade Lógica Aritmética presente dentros das CPUs. É na Alu que as operações aritméticas e lógicas são feitas, como soma, subtração, and, or, xor, not, shfit, rotate, etc.

Esta é a parte 6 dessa série onde estou implementando uma engine de raycasting, usando o jogo Wolfenstein 3d como referência. Neste vídeo mostra a parte matemática de como criar os vetores que vão dar a direção dos raios. A parte matemática é bem simples.

Neste vídeo falo sobre os multiplexadores, que são encontrados tanto nos cartuchos como internamente nas Cpus. No vídeo eu explico sobre os Decoders e sobre o Multiplexadores.

Esta é a parte 5 da série onde estou programando uma engine de Raycasting. Neste vídeo dou mais detalhes sobre o plano da câmera e inserimos no código esse novo vetor que irá gerar o plano da câmera e que será usado na criação dos raios.

Este é o primeiro vídeo onde mostro como desenhar um fractal. Neste vídeo eu desenho uma árvore de fractal, que é bem simples de implementar.

Neste vídeo eu mostro como podemos criar elementos Html usando diretamente o P5. O P5 possui muitas funções já prontas para criar diversos elementos.

Neste vídeo começo a explicar como um processador funciona. A explicação de como as Cpus dos consoles funcionam vão levar alguns vídeos, mas neste vídeo eu começo a mostrar como é a estrutura interna de um processador.

Neste vídeo falo sobre uma característica pouco conhecida mas muito interessante do Python que é o encadeamento de operadores de comparação. Com essa construção da linguagem conseguimos realizar comparações matemáticas da forma como pensamos na vida real, encadeando as operações de comparação.

Se você não tomar cuidado, uma simples variável colocada na ordem errada pode fazer o seu código rodar muito mais lento. Neste vídeo eu mostro um código que fica muito mais lento apenas trocando duas variáveis de lugar.

Neste vídeo eu falo um pouco sobre os métodos mágicos em Python, que são umas das principais características do Python. Com os métodos mágicos conseguimos incorporar funcionalidades nas nossas classes para podermos usar as construções da linguagem com essas classes.

Esta é a quarta parte desta série onde implemento uma engine de Raycasting. Neste vídeo introduzo o conceito de câmera.

Neste vídeo eu mostro como inverter variáveis sem usar uma variável temporária, usando XOR. Isso pode ser útil para sistemas embarcados ou aplicações que precisam de muita velocidade.

Neste vídeo eu implemento um visualizador para o algoritmo Bubble Sort. Este é um algoritmo muito conhecido, principalmente por ser bem lento. Implemento e explico o algoritmo e um visualizador, onde geramos uma animação que mostra a evolução do algoritmo.

Neste vídeo mostro como criar layers no canvas. Com isso conseguimos fazer animações com características diferentes e juntar tudo em uma coisa só depois. Para isso usamos a função CreateGraphics do P5.js.

Neste vídeo eu explico o que são instruções em um processador e já começo a entrar na parte do Assembly do Snes e do Mega Drive. Mostro os debuggers que iremos usar em cada sistema e explico os detalhes de algumas instruções.

Esta é a terceira parte desta série onde implemento uma engine de Raycasting. Neste vídeo explico mais a fundo como o Raycasting funciona e dou os passos iniciais na estrutura do projeto.

Neste vídeo explico sobre Produto Escalar de vetores, que é muito útil em programação de jogos. Com produto escalar conseguimos facilmente criar um cone de visão para detecção de objetos.

Neste vídeo eu mostro como podemos nos preparar para entrevistas de emprego na área de programação utilizando o HackerRank. O HackerRank é um site onde podemos aprender bastante e fazer vários testes e desafios similares aos que encontramos em muitas entrevistas técnicas.

Neste vídeo explico sobre vetores unitários e como normalizar vetores. Vetores normalizados simplificam as contas e sempre aparece em códigos que trabalham com vetores.

Neste vídeo mostro o algoritmo de Kadane, que é um algoritmo bem conhecido para resolver o problema do subarray contíguo de soma máxima. Apresento 3 formas de resolver esse problema.

Neste vídeo foco mais na subtração de vetores, que é muito útil para fazer um objeto apontar para outro objeto.

Neste vídeo faço uma animação de uma chuva em JavaScript. Uso a biblioteca P5.js pra facilitar na parte gráfica. Muito simples de fazer.

Neste vídeo explico algumas operações com vetores, como adição, subtração, multiplicação por escalar e rotação. Criei uma animação onde uma bolinha persegue o mouse para mostrar esses conceitos.

Neste vídeo falo sobre registradores e o básico que precisamos saber para quem trabalha com software. Trabalharemos com registradores constantemente no futuro, então é bom ter uma noção do que são fisicamente.

Neste vídeo resolvo uma questão sobre agrupamento de anagramas. Dado uma lista de palavras o problema é juntar as palavras que são anagramas em arrays separados.

Neste vídeo começo uma introdução sobre vetores. Vetores são muito usados na prática, e é importante ter uma noção do que são e como trabalhar com vetores para começar a implementar várias coisas interessantes.

Neste vídeo explico sobre complemento de 2 usando o exemplo do odômetro. Complemento de 2 é a forma mais usada para representarmos números negativos em binário.

Neste vídeo eu implemento o efeito de Game Over do jogo Wolfenstein 3D, chamado FizzleFade. O efeito usa algo chamada Linear-Feedback Shift Register, que eu explico no vídeo.

Neste vídeo eu mostro como colocar textos no canvas usando as funções do P5.js. Muitos projetos, como jogos, precisam mostrar textos na tela.

Neste vídeo explico porque usamos clock nos circuitos e também explico o elemento Flip-Flop, que tem um papel muito importante nesta questão.

Neste vídeo eu explico como as memórias dos consoles funcionam, tanto a Ram, quanto a Rom. Explico as funções de todos os pinos dos chips. Esse conhecimento vai ser útil posteriormente quando formos fazer algo mais avançado nas aplicações.

Neste vídeo eu codifico um simulador de código para ser usado na geração de Thumbs. Mostro passo a passo como fazer.

Neste vídeo faço a arte que está na thumb do vídeo usando Javascript com a biblioteca P5.js. Bem facinho de programar.

Neste vídeo eu crio a arte que está na Thumb do vídeo usando Javascript com a biblioteca P5. É muito simples de implementar.

Neste vídeo eu continuo o assunto do vídeo anterior, mostrando como criar portas lógicas usando transistor. Isso é importante pra saber como os circuitos lógicos dentro dos processadores funcionam.

Neste vídeo eu implemento um algoritmo que retorna pontos aleatórios em um triângulo. Isso pode ser útil em jogo por exemplo. Implemento dois métodos diferentes.

Neste episódio da série eu mudo um pouco assunto e vou lá para as entranhas dos hardwares para explicar o que são os transistores. É muito importante saber como os transistores funcionam para ter uma noção maior sobre como as coisas acontecem nos hardwares.

Neste vídeo eu falo sobre Perlin Noise, que é muito útil para gerar números aleatórios que precisem de uma continuidade.

Neste vídeo eu mostro como tocar um som usando JavaScript com P5. Isso é muito útil em pra jogos e aplicações que precisam de músicas ou efeitos sonoros.

Neste vídeo eu falo como são os mapas do Wolf3D e como serão implementados no código.

Neste vídeo mostro como carregar imagens no Canvas. Com o P5 o processo fica muito simples.

Nesta parte 3 do curso falo mais sobre o hardware do Mega Drive, mostrando os diagramas de bloco e o esquemático. Faço uma comparação com o Snes apontando as diferenças e similaridades.

Neste vídeo eu mostro a função "preload" do P5js. Esta função roda antes do "setup" e serve para carregarmos arquivos no início da aplicação.

Neste vídeo eu mostro como fazer desenhos de objetos complexos e customizados. Isso é possível com os Shapes. Com Shapes conseguimos facilmente desenhar objetos customizados.

Neste vídeo eu faço uma animação passo a passo com retângulos girando na tela com cores diferentes. O efeito final é bem bonito.

Neste vídeo mostro como deixar o canvas em tela cheia. Isso é muito legal para visualizarmos as animações com o tamanho total.

A função Scale serve para aumentar o tamanho dos eixos de coordenada. Com isso as unidades de medida passam a ter um tamanho maior ou menos em pixels. Isso é útil para aumentar ou diminuir o tamanho do que está desenhado no canvas.

Neste vídeo mostro como salvar o contexto do P5 usando o Push e o Pop. Isso é muito útil na hora de fazer as animações.

A função Rotate rotaciona os eixos de coordenada, e com isso conseguimos desenhar figuras inclinadas. No vídeo explico como isso funciona e dou exemplos.

Neste episódio eu falo mais sobre o hardware do Snes, mostrando os diagramas de bloco e o esquemático. Temos que conhecer bem o hardware que estamos trabalhando, então os diagramas ajudam muito nisso.

Nesta série de vídeos vou programar do zero uma Engine de Raycasting para podermos navegar em mapas que gerarmos futuramente. Estou me baseando no jogo Wolfenstein 3d lançado em 1992 pela Id Software. O jogo usa o método de Raycasting para a criação dos gráficos e estarei explicando passo a passo nesta série de vídeos.

O uso de funções trigonométricas em programação é muito comum, então neste vídeo tento relembrar o básico sobre Seno, Cosseno e ângulos que aprendemos na escola. É muito importante dominar esse assunto.

Dado uma variável de 32 bits, o peso da variável é definido como sendo a quantidade de bits "1" na variável. Dado um número de 32 bits, encontre o número mais próximo deste número que tenha o mesmo peso.

A função "translate" serve para mudar o centro do eixo de coordenadas de posição. Isso é muito útil em vários cenários.

Neste vídeo eu introduzo a função "map" do P5js. Esta função é muito útil pois conseguimos facilmente mapear um range em outro range. É preciso prática pra pegar o jeito com essa função.

Esta é a segunda parte da codificação do algoritmo de compressão RLE (Run Length Encoding). No primeiro vídeo eu expliquei sobre a compressão e codifiquei o compressor. Neste vídeo eu codifico o descompressor.

Neste vídeo eu explico sobre loops em JavaScript, mostrando as variedades disponíveis com alguns exemplos.

Neste vídeo eu codifico um compressor para um algoritmo RLE (Run Length Encoding). O RLE é um método de compressão bem simples e que era muito usado nos anos 80 e 90 em jogos. Ainda é muito usado em conjuntos com outros métodos.

Neste vídeo eu introduzo os ARRAYS em Javascript, que são uma estrutura onde podemos armazenar variáveis em sequência e acessá-las individualmente a qualquer momento. Veremos que Arrays são um tipo especial de Objetos em JavaScript.

Nesta questão você tem que codificar uma função que recebe uma matriz ordenada e retorna a quantidade de números negativos na matriz.

Neste vídeo eu introduzo o conceito de Classes em JavaScript, que foi uma adição das últimas versões de JavaScript que melhora a sintaxe da linguagem em muitas situações.

Neste vídeo falo de um dos principais conceitos do Javascript, que são as funções construtoras.

Neste vídeo mostro como criar objetos com funções fábricas. Isso é muito comum em Javascript e serve para entendermos as funções Contrutoras que falaremos depois.

Neste vídeo continuo o assunto do vídeo anterior e dou mais detalhes sobre o "this" no contexto dos objetos. Isso é importante pra entender como JavaScript funciona.

Este vídeo introduz os Objetos em JavaScript, explicando os conceitos básicos.

A função "random" serve para gerarmos números aleatórios dentro de um range. Isso é muito útil em vários tipos de programas.

Neste vídeo vamos aprender a configurar o Fps do canvas. Isso é útil para controlar a velocidade de atualização das animações.

Neste vídeo eu explico o operador ternário em JavaScript, que é muito usado na prática. Esse operador deixa o código mais compacto e é importante conhecer pois sempre aparece nos códigos.

O assunto do vídeo é sobre condicionais em Javascript, onde explico o uso do "if", "else", "switch" e outros detalhes.

Neste vídeo falo sobre variáveis booleanas em JavaScript. Falo também sobre conversão de dados e sobre os operadores "==" e "===".

Crie uma função que receba um número 'n' inteiro maior que zero e retorne o enésimo número de Fibonacci.

Explico neste vídeo como usar o mouse para interagir com um programa JavaScript com o P5.js. Com isso é possível criar jogos e todo tipo de aplicações que usam o mouse.

Neste vídeo explico o básico de funções em JavaScript, que é a base fundamental para as abstrações de código.

A paridade de um dado é relacionado com a quantidade de bits "1" do dado. Temos que descobrir se a quantidade é par ou ímpar.

Neste vídeo dou uma visão geral sobre os tipos de variáveis presentes no Javascript.

Este é o primeiro vídeo de uma série onde estudaremos programação utilizando consoles antigos, principalmente o Snes e o Mega Drive.

Implemente uma função que recebe uma variável como parâmetro e retorne o número de bits "1" dentro da variável. Neste vídeo eu explico várias abordagens.

Neste vídeo mostrarei como rodar código JavaScript localmente usando o Node.js. Isso é muito útil durante o aprendizado de JavaScript.

Dado uma lista qualquer, inverter a lista in-place, ou seja, sem a criação de uma nova lista.

Neste vídeo eu crio um código que tenta adivinhar o conteúdo de imagens usando Machine Learning. Isso é chamado de Classificação de Imagens.

Este é um tutorial que ensina como fazer o código que adiciona o efeito de arrastar e soltar em uma página.

Neste vídeo tentarei mostrar de forma simples o que é Machine Learning e o que iremos usar ao longo dos próximos vídeos desta série.

Neste vídeo aprenderemos como criar um projeto localmente usando JavaScript com a biblioteca P5.js no VSCode. É muito fácil.

Neste vídeo aprenderemos a usar cores em Javascript, o que pode ser levado para qualquer outra linguagem.

Este é o primeiro vídeo do curso de JavaScript com P5.js. Vamos aprender do início como programar várias coisas visuais e interessantes usando JavaScript junto com a biblioteca P5.js.

Neste vídeo aplicaremos o que aprendemos até aqui para criar um efeito de gravidade.

Vamos criar um código base para ser usado em futuros projetos usando o Canvas.

Neste vídeo vamos aprender como fazer animações no Canvas. Após aprender isso o céu é o limite :D.

Este é o primeiro vídeo em uma série de tutoriais sobre o Canvas. Nesta parte 1 tratamos inicialmente de imagens estáticas.

Imagine um array de números onde cada número aparece duas vezes e em posições aleatórias. Apenas um número aparece uma única vez. Crie um algoritmo que encontre esse número único.

Vamos codificar em Python um descompressor de um jogo de Mega Drive? Neste vídeo eu faço a engenharia reversa de uma rotina de descompressão em assembly.

Se você for desenvolver uma aplicação Python que use bibliotecas externas, sempre use o Virtualenv pra facilitar sua vida.

Este é o primeiro vídeo de um projeto de implementação de um blockchain do zero. Parte 2 do vídeo.

Este é o primeiro vídeo de um projeto de implementação de um blockchain do zero.

O Xor é uma operação binária que serve para inverter bits. Neste vídeo eu mostro uns exemplos práticos de como usar o Xor.

É muito comum a manipulação de dados binários no dia a dia da implementação de código. Você como programador tem que dominar esse assunto.

Por que os programadores usam números no formato hexadecimal? Não complica mais? Essas são dúvidas comuns para quem está começando.

Por que os computadores usam o sistema binário? Neste vídeo tento dar uma visão geral do motivo de usarmos o sistema binário.

Este é o primeiro vídeo do canal. Neste vídeo eu me apresento e falo um pouco do canal e do site.