DEV Community: Renan Marquetti

Quantas cartas tem em uma torre de cartas com N andares?

Renan Marquetti — Thu, 28 Aug 2025 02:28:29 +0000

Por que esta pergunta?

Você pode estar se perguntando: por que devo saber responder uma pergunta como essa? Isso faz alguma diferença na minha vida?

Pois bem, eu nunca entendi a força de uma pergunta (e resposta) como essa, até uma recente experiência, então decidi compartilhá-la com a comunidade, para dar exemplo de como os detalhes podem fazer imensa diferença.

Recentemente participei de um happy hour promovido pela empresa que eu trabalho atualmente (woovi).

Todos nós chamamos um motorista de aplicativo, e o CTO veio conosco no carro.

Durante o fluir da conversa, chegamos ao assunto matemática.

Eu gosto de matemática, sempre me dei bem desde o colégio.

O CTO queria nos mostrar como, às vezes, perguntas simples podem nos levar a raciocínios complexos e como a matemática é o melhor método para ordenar a razão humana.

Então ele fez a seguinte pergunta:

Quantas cartas tem em uma torre de cartas com 10 andares?

Confesso que isso me chamou a atenção logo de cara, é o tipo de pergunta que ajuda a dar um maior sentido para a minha vida, então decidi tentar até conseguir.

Estávamos todos no carro, a caminho do happy hour.

O meu celular estava sem internet, então não tinha como usar nenhuma ajuda externa; era eu e o problema.

Fiquei uns 20 minutos pensando, consegui chegar a uma fórmula que parecia resolver a questão, fiz as contas de cabeça e respondi:

152.

Na conferência, viram que estava errado; o correto era 155. Errei por 3 cartas.

Vi que tinha cometido alguns erros de raciocínio e de cálculo.

Pensei mais profundamente sobre o problema, corrigi a minha fórmula e o meu cálculo, com isso cheguei à resposta 155.

Não disse o valor de imediato, visto que sei que a grande capacidade da mente humana é saber lidar com raciocínio abstrato, então decidi proclamar primeiro a fórmula para depois o resultado.

Todos acharam legal o ocorrido, estamos perto do destino, mas conseguiram validar que a fórmula produzia valores corretos.

Este assunto chegou até o nosso happy hour, gostaram de saber, mas fizeram a pergunta que faz qualquer um tremer: por que esta fórmula é correta? Como chega-se nela?

Como cheguei à resposta?

Eu não conseguia explicar de uma forma fácil como tinha chegado na resposta, isso gerou confusão em alguns.

Então decidi corrigir essa questão, simplifiquei a fórmula e o raciocínio para chegar até lá, está a fórmula simplificada:

O meu raciocínio se deu da seguinte forma:

Separe a torre em células de três cartas como essa.

Resolvendo com 1 andar:

Observe que, em uma torre com 1 andar, só cabe uma célula.
Logo, poderíamos deduzir que, em uma torre com um andar, serão necessárias 3 cartas, mas isso apenas se quisermos montar a torre com as cartas da base também. Como queremos a torre sem a base, temos que descontar a base.
Logo, a dedução correta seria: uma célula vezes 3 cartas menos a base, 1*3 - 1 = 2.

Resolvendo com 2 andares:

Vamos seguir a mesma linha de raciocínio anterior, mas com um degrau a mais, e ver o que mudou.
Para fins didáticos, conte os andares de cima para baixo.
Observe que no 1° andar ainda temos 1 célula; no 2° andar, 2 células.
Observe também que temos 2 cartas de base no segundo andar.
Com isso, podemos deduzir que a conta seria a seguinte: uma célula do 1° andar, mais 2 células do 2° andar, menos as 2 cartas da base, (1+ 2) * 3 - 2 = 7.

Entendendo o padrão

Apesar de ser poucos exemplos, conseguimos observar alguns padrões aqui:

A quantidade de células por andar é igual ao número do andar, logo deduz: 1° andar -> 1 célula, 2° andar -> 2 células, etc...
A quantidade de cartas na base também é igual ao número do andar, então entendemos que: 1° andar -> 1 carta na base, 2° andar -> 2 cartas na base.

Com essas observações, já conseguimos deduzir que, para chegar ao total de cartas contidas em uma torre de cartas com N andares, devemos:

Somar o total de células contidas em cada andar.
Multiplicar o total de células pela quantidade de cartas em cada célula (nesse caso, 3).
Pegar o resultado e subtrair as cartas que estão na base da torre (sempre será igual à quantidade de andares na torre).

Montando a fórmula

O raciocínio é bem simples, na verdade, mas você pode ter se deparado com um problema logo de cara.

como somar todas as células presente em todos os andares?
se tiver 100 andares, vou ter que somar 100 + 99 + 98 ... + 2 + 1?

A sua dúvida é bem pertinente, na verdade, mas tem uma solução fácil.

A grande maioria das pessoas conhece o operador matemático fatorial (símbolo: !), mas, fora ele, existem diversos outros, entre eles o operador termial (símbolo: ?), que atende exatamente essa demanda.

Ao estudarmos o operador terminal, descobrimos que podemos usar a seguinte fórmula para resolver a questão mais facilmente e nos poupar esse trabalho massante:

Se usarmos essa fórmula como a solução base para o primeiro passo da solução, basta adicionar as operações do segundo e terceiro passo e teremos a fórmula completa (não simplificada):

Simplificando um pouco mais a fórmula

Nós conseguimos reduzir um pouco a complexidade ao simplificarmos uma operação da nossa fórmula.

Observe que temos 2 constantes na nossa fórmula:

A divisão por dois da fração e a multiplicação por três podemos unir as duas em uma única operação de multiplicação, visto que:

Com isso, podemos simplificar a fórmula para:

Agradecimentos

Muito obrigado a você, leitor, que veio até aqui.

Acompanhar uma linha de raciocínio como essa não é um privilégio de todos.

Também quero agradecer ao meu CTO que me incentivou a escrever esse artigo.

Como construir um computador do zero - Controler

Renan Marquetti — Sat, 16 Aug 2025 03:45:29 +0000

O coração do nosso projeto é a central que dispara e opera todos os comandos do nosso computador, tem por objetivo principal interpretar e executar os comandos do nosso software.

É um dos componentes mais sensíveis do nosso projeto, aqui o menor erro faz com que tudo simplesmente não funcione, além de ser difícil encontrar o erro.

Esta seção é composta de alguns componentes, sendo eles:

Registrador de instruções: um velho conhecido nosso, tem por objetivo guardar e persistir a instrução em execução naquele ciclo.
Program Counter: é o componente que dita (e incrementa) qual instrução vai ser executada naquele ciclo.
Contador de clock: dita em qual etapa de execução da instrução estamos (temos 5 etapas por padrão).
Controler: agrega todos os componentes acima e dita quais sinais cada componente vai receber naquela etapa de processamento.

Registrador de instruções

Esse registrador se difere um pouco dos outros pelo fato de, além de ter as entradas e saídas padrão, ele possuir uma saída especial que envia um sinal com os 4 bits mais significativos diretamente para o controlador.

Esse sinal contém o valor da instrução que vai ser executada dentro do ciclo de instrução.

Esquema deste componente:

Program Counter

Este componente não tem um nome muito assertivo, isso pode levar algumas pessoas à confusão, mas o seu funcionamento é muito simples.

Imagine um contador que começa em 0 e vai incrementando (somando mais um) sempre que você clica em um botão. Pois bem, essa é a função deste componente.

Este componente possui um valor interno que começa em 0 e vai incrementando sempre que termina o ciclo de instrução anterior, isso é importante quando se quer ler ou executar os dados da memória de forma sequencial (o padrão de quase todo software).

Apesar de ler os dados da memória de forma sequencial ser o modo padrão de execução, também é possível pular para qualquer outro valor definido no nosso software, chamamos isso de jump (ou pulo).

O valor contido dentro do contador de programa determina qual endereço de memória será lido no início do ciclo de instrução. Como o nosso contador sempre começa em 0, isso quer dizer que o nosso software sempre será escrito nos primeiros endereços de memória.

Esquema deste componente:

Contador de clock

O nosso computador contém um ciclo de máquina de 5 etapas, isso quer dizer que todas as instruções do nosso computador têm que ser executadas em 5 clocks ou menos.

Instruções mais complexas requerem mais ciclos para serem executadas, e instruções mais simples requerem poucos ciclos para serem executadas.

Este componente tem a função de informar em qual das 5 etapas de clock a instrução está, ele é um importante componente auxiliar do controlador.

Esquema deste componente:

Controller

Este componente é verboso tanto quanto sensível, mas apesar destas condições, o seu funcionamento é simples.

Este componente tem a função de receber um sinal de instrução e, a partir disto, ativar os componentes corretos para execução total da instrução.

Esquema deste componente:

Como construir um computador do zero - Output

Renan Marquetti — Sat, 16 Aug 2025 03:41:12 +0000

Está parte serve para armazenar converter e exibir a saída do nosso software, apesar de ter poucos componentes (apenas 2 externos e um interno) um deles se destaca pela sua grande verbosidade

Este sistema faz o uso de 3 componentes, sendo eles

Registrador de saída: um velho conhecido nosso, tem a função de armazenar e persistir os dados de saída do nosso computador.
ComplementoDe2: é um componente interno, utilizado para exibir números com sinal negativo.
ConversorBase10: ele converte um numero de 8 bits em seu equivalente decimal.

Registrador de Saída

O registrador já um dos nossos velhos conhecidos, para se iterar melhor, basta olhar os nossos artigos anteriores.

ComplementoDe2

Este componente auxiliar é necessário para exibir números com sinal, isso se deve ao fato de que é possível interpretar um numero binário, de duas formas, com sinal e sem sinal.

Números com sem sinal sempre partem de 0, não sendo possível representar números negativos, deve ser usado, para representar valores que nunca vai ser menor que 0 (distancia, velocidade, volume, etc...)

A vantagem deste sistema é que você dobra o valor máximo que pode ser armazenados em N bits, por exemplo um numero de 8 bits pode ir de 0 até 255, sem sinal.

Números com sinal devem ser usados para representar valores que podem ser menor do que 0 (temperatura, pagamentos, etc...)

A vantagem desse sistema é que é possível representar números menores do que 0, a custo de um teto menor para números positivos, por exemplo um numero de 8 bits com sinal pode ir de -128 até 127.

Este componente é necessário para converter o sinal de saída de números como sinal para os valores corretos, caso contrario o nosso sistema trataria todos os inputs como valores com sinal.

Esquema deste componente:

ConversorBase10

Tenho um carinho especial por esse componente porque ele foi o meu maior componente 100% autoral (fiz completamente da minha cabeça, não busquei nada pronto) neste projeto.

O nosso computador tem base binária, isso quer dizer que os números também são computados em base binária, isso facilita o projeto como um todo, mas dificulta a leitura para humanos.

Sendo assim, então é necessário uma forma de converter o sistema de binário para decimal.

Este componente realiza essa função, ele converte o sinal de 8 bits em 3 sinais de 4 bits, sendo que cada sinal de saída representa os valores de unidade, dezena e centena.

Também possui mais uma saída especial, que é ativada quando o número é negativo, usamos esse sinal para exibir o carácter '-' antes do número em exibição.

Esquema deste componente:

Entrada.

Saída da unidade.

Saída da dezena.

Saída da centena.

Como construir um computador do zero - Unidade Lógico Aritmética

Renan Marquetti — Sat, 16 Aug 2025 03:25:28 +0000

Está parte do sistema é responsável pelo processamento lógico no nosso sistema, é onde de fato os dados são transformados, compostos e decompostos, até atingir o resultado desejado

Esse componente é o mais complexo do nosso sistema, porque agrega muitas regras de negocio em um único espaço

Está sessão do sistema é composta por 3 componentes, sendo eles:

Registrador A (ou Acumulador): é um registrador usado para persistir e guardar os resultados das operações do sistema
Registrador B: é o registrador auxiliar, usado para "memoria de trabalho", tem a função de receber o valor a será processado sobre o valor do Registrador A.
ULA: é de fato a onde ocorre o processamento, tem por objetivo processar os valores dos registradores A e B e armazenar novamente esse valor no registrador A

Registradores A e B

Os Registradores já foram abordados em artigos anteriores, e todas as suas conexões estão descritas na imagem acima

Unidade Lógica e Aritmética (ULA)

Este componente é capaz de processar os valores dos Registradores A e B de diversas formas diferentes, conseguimos fazer diversas operações, sendo elas:

Adição (ADD)
Subtração (SUB)
Lógica e (AND)
Lógica ou (OR)
Lógica ou exclusivo (XOR)
Lógica negação (NOT)

Os inputs ALU_0 e ALU_1, são utilizados para selecionar a operação deseja, veja a tabela a baixo

ALU_0	ALU_1	Operação
0	0	ADD/SUB
0	1	OR
1	0	AND
1	1	XOR/NOT

Observe que nos casos em que á mais de duas operações por seleção, será feito uma desambiguação em inputs específicos, portanto sendo necessário nos casos:

ADD/SUB: utilize o input N_SUB_ADD em 0 para SUB e 1 para ADD
XOR/NOT: utilize o input N_XOR_NOT em 0 para XOR e 1 para NOT

À também mais um input de entrada: ALU_OUT, server para liberar o resultado da operação para o BUS

Além desta, há mais uma saída: Carry_out, está saída é ativa quando o resultado das operações de soma ou subtração resultam em um overflow.

Este é o esquema desse componente:

Como construir um computador do zero - Memória Ram

Renan Marquetti — Sat, 16 Aug 2025 03:02:04 +0000

Memoria Ram

A rainha do nosso computador, é o sistema que tem por objetivo armazenar os dados dentro do nosso computador, tudo está aqui (ou quase tudo), programas, dados base, dados de pós processamento, etc...

A memória ram na verdade é muito similar a memoria rom, com a diferença que a memoria ram aceita tanto ler quanto gravar dados nela, principalmente durante a execução do software

Sistema de ram é composto de basicamente de 3 componentes:

Registrador de 8 bits
Memory Address Register 4 bits (MAR)
Random Access Memory 16 bytes (RAM)

Registrador de 8 bits

Esse é o componente mais utilizado no nosso projeto, tem a função de armazenar uma pequena quantidade de informação (8 bits ou 1 byte) e persisti-la entre os ciclos de clock, será o componente mais importante de todo o sistema de memoria do computador.

Apesar desse alto grau de importância o componente é muito simples, ele possui 1 entrada e saída para o bus (ou barramento), mais uma entrada para o pulso de clock e outra entrada para o pulso de reset.

todas essas estradas são padrão em praticamente todos os componentes do nosso computador, mas o registrador possui mais duas entradas especificas para o registrador, sendo elas permitir entrada de dados (REG_IN) e permitir saída de dados (REG_OUT)

Esquema deste componente:

Memory Address Register 4 bits (MAR)

Este componente tem a função de registrar (ou armazenar) os endereços de memoria que vão ser utilizados naquele sub-ciclo da instrução.

É muito similar ao componente acima, mas o Registrador é de uso geral, já o MAR é de uso especifico, só será usado nesta cessão.

Alem das entradas e saídas padrão (BUS_IN, CLK e RESET) ele possui outras entradas de uso especifico, sendo elas:

PGR_RUN: é o input que altera o estado do nosso componente para operar em modo de programação.
MAR_DIP: é a onde fica o input de endereço, quando o computador está em modo de programação.
MAR_IN: quando ativo permite a entrada de um novo valor de endereço, caso contrario será mantido o valor vigente

À também uma saída de uso especio (MAR_ADDR) que será utilizada apenas para abastecer a memoria RAM com o endereço que se deseja ler ou gravar naquele momento.

Esquema deste componente:

Random Access Memory 16 bytes (RAM)

A Memoria RAM tem a função de armazenar os dados do nosso computador, sendo possível alterar o valor contido em qualquer endereço, equanto o nosso software executa.

Mais do que um simples sistema de memoria, a RAM é a representação máxima do estado atual do nosso computador, tudo começa e passa por ela.

Apesar de sua enorme importância o seu funcionamento é bem simples, basta selecionar um endereço que deseja consumir naquele momento e escolher as operações de leitura ou gravação.

Este componente possui as entradas e saídas padrão (BUS_IN, BUS_OUT, CLK e RESET), e possui mais alguma entradas para uso especifico:

ADDR: é o input para seleção do endereço atual de operação.
RAM_IN: quando ativo insere o valor do BUS no endereço selecionado.
RAM_OUT: quando ativo envia o valor do endereço selecionado para o BUS.

Esquema deste componente:

Como construir um computador do zero - Sistema de Input

Renan Marquetti — Sat, 16 Aug 2025 02:32:45 +0000

Sistema de Input

Esta seção do computador é onde se encontram os componentes que recebem os inputs do usuário, ou seja, é onde tudo começa.

Nesta seção, o usuário consegue dar "partida" no computador, retesar e "zerar" o seu estado (apagando os programas em execução).

Se o nosso computador fosse um carro, aqui é onde ficaria o "cockpit", pedais de embreagem, acelerador, freio, etc...

Esse sistema é composto por 4 componentes:

botão de reset (freio)
botão programa em execução (embreagem)
gerenciamento de clock (acelerador)
Memória ROM (volante)

Vamos explorar cada um destes componentes.

Botão de Reset

É o componente mais simples do nosso sistema, ele literalmente é um botão que dispara um pulso no computador, esse pulso vai ser capturado pelos demais componentes do sistema, que irá "zerar" todos os seus valores internos (ficaram mais claros com o avançar do projeto).

Esquema do componente:

Pino programa em execução

Esse pino dita o modo de execução do nosso computador, são dois modos possíveis, sendo eles: modo de programação e modo de execução.

Modo de Programação: esse modo serve para preparar o computador para receber as instruções do programa, serve literalmente para isso, é um modo em que não é executada nenhuma instrução, elas apenas são gravadas na memória para posterior consumo.

Modo de Execução: nome autoexplicativo, ele começa a executar o software gravado na memória do nosso computador, seguindo assim o seu ciclo normal de computação. Quando dá certo, a gente nota que a vida passa a fazer sentido novamente, e no meio de um imenso oceano de dor e angústia, a verdade triunfa e mais nada será como antes.

Ou não.

Apesar da explicação longa, o sistema é inversamente curto e simples.

Esquema do componente:

Gerenciamento de clock

Este é o subsistema responsável por controlar o clock (ou pulsos) do nosso computador, é um dos componentes mais simples e importantes do nosso computador.

Ele é responsável por sincronizar o processamento do nosso sistema, fazendo com que todos os componentes trabalhem em conjunto de forma ordenada.

Possui 3 pinos de entradas no componente: entrada de seleção de modo de execução (mais detalhes à frente), entrada de clock manual, entrada para a instantânea do sistema (utilizada para encerrar a execução do software).

O componente também possui 2 modos de operação, sendo eles: manual e automático.

No modo automático, ele libera pulsos em uma frequência constante, sem depender de nenhum outro input do usuário.

No modo manual, é o usuário que libera o pulso através de um botão. Usamos esse modo para verificar o processamento passo a passo, tem por objetivo entender e verificar o correto funcionamento do computador (vai por mim, esse botão está aí por um bom motivo).

Esquema do componente:

Memória ROM

Apesar de ser um componente grande, tem uma função igualmente simples, é como se fosse o "disquete" (ou pendrive para os mais novos) que vamos usar para instalar o programa.

Tem a única função de guardar os bytes do nosso programa e liberar conforme for solicitado, é mais um facilitador que uma obrigatoriedade, tem como seguir sem ele, mas a dor de cabeça é um pouco maior.

Esquema do componente:

OBS: esse componente utiliza o "ProgramCounter", um componente que vamos especificar mais adiante, na seção de controle, se preferir pode pular esse componente por hora.

Como construir um computador do zero - Introdução.

Renan Marquetti — Sat, 16 Aug 2025 02:21:14 +0000

O que leva alguém a construir um computador do zero, nos dias atuais?

Eu comecei a programar relativamente tarde (por volta dos 24 anos), mas foi amor à primeira vista, me apaixonei logo de cara.

No começo da minha jornada de estudos, eu encontrei diversos desafios, mas pude ser agraciado com vitórias maiores ainda.

Sempre fui uma pessoa curiosa, constantemente buscava entender como o mundo em minha volta, desde o formar das gotas de chuva, até as questões profundas da alma humana (fique tranquilo, não vamos tão longe nestes artigos).

Com o computador não foi diferente, quando tinha meus meros 14 anos de idade, o pai comprou um computador para nós (eu e meu irmão), desde então sempre tive curiosidade de saber como tudo aquilo funcionava por baixo do capô.

Bem, o tempo foi passando, e uma década e pouco depois já estava aprendendo a programar.

Como todo começo, comecei por baixo e um pouco perdido.

Até que encontrei o canal do Fabio Akita, em especial um vídeo intitulado Aprendendo sobre Computadores com Super Mario (do jeito Hardcore++), um vídeo em que ele ensina a importância da base da computação.

Eu me apaixonei por tudo isso, percebi que a programação tinha uma verdade profunda, que valia a pena buscar, algo que me dava o prazer de continuar estudando, e fazia tudo aquilo valer a pena.

Foi meu primeiro contato com esse tipo de conteúdo, eu queria mais, infelizmente, devido a questões monetárias, fui obrigado a deixar isso para um segundo momento.

Até que, 3 anos depois, tomo conhecimento da UBL, era tudo o que eu precisava, foi o pontapé para eu tomar uma atitude e iniciar os meus estudos formais na ciência da computação.

A primeira matéria do curso é circuitos digitais.

Enquanto estudava, percebi que poderia unir diversos circuitos simples e construir algo maior e mais robusto.

Eu estava buscando um projeto para consolidar e validar os meus conhecimentos em circuitos digitais, nesse momento me lembrei da série do Bean Eater, na qual ele constrói um computador do zero usando componentes eletrônicos.

Era o projeto que eu estava buscando, caía como uma luva, tudo ficou ainda melhor quando, conversando com um grupo de programadores, tomei conhecimento de uma série inspirada nessa, só que em solo nacional.

A série em questão é a Construa um Computador de 8 Bits do Eng. Wagner Rambo, esta maravilhosa série, serviu de base para este projeto, com uma pequena diferença.

Wagner Rambo é um Engenheiro em Eletrônica, Computadores e Telecomunicações (sim, o cara é brabo demais), ou seja, todo o computador foi montado usando hardware, então tomei a liberdade e "convertemos" todos os componentes para usar apenas portas lógicas e flip flops.

Mentalidade

Apesar de ser um projeto mais verboso do que complexo, acho importante compartilhar um pouco da mentalidade que exercitei para executar este projeto.

Como já descrito acima, eu iniciei este projeto para consolidar e fixar os conhecimentos em circuitos digitais, então ele exige algum nível de conhecimento prévio (mais a respeito nas próximas seções).

Imagine que está preparando um carrinho de concreto, o que você precisa? Areia, cimento, brita e água, mas apenas isto não é o suficiente, você ainda tem que misturar tudo e esperar secar.

É com esta mentalidade que abordei esse projeto, e o conforto de saber que com isso estamos um passo mais próximo da excelência.

Introdução

Como encarar a leitura desse artigo?

Existem diversas formas de dissecar um assunto complexo, mas acredito que o ideal partirmos do todos para as partes.

Quero dizer que devemos primeiro tomar conhecimento dos principais conceitos que dão sentido e razão ao nosso projeto.

Então antes de botar a mão na massa devemos primeiro entender como a massa funciona, qual problema ela resolve, e porque veio existir.

Assim definiremos como cada pequena parte contribui para o todo.

Isto é essencial para não caminharmos como folhas ao vento

Conhecimentos prévios

sistema digitais

Para aprender sistema digitais eu recomendo fortemente o repositório da ubl: grade, vídeo, livros (recomendo)

Setup

Logisim Evolution

O Logisim Evolution é um software educacional para projetar e simular circuitos lógicos digitais, será a ferramenta base para desenvolver e simular o nosso projeto.

O software é bem intuitivo, mas existem diversos artigos e vídeos que o auxiliarão nesse aprendizado.

Eu recomendo começar lendo a documentação externa em seu repositório.

Conceitos base

aviso: não se preocupe com o que a caixa faz, mas qual problema ela resolve, primeiro se pergunte, porque? para depois se perguntar, como?

Calculadora VS Computador

Muitos acreditam que um computador é uma calculadora turbinada, mas nada poderia estar mais longe da verdade, esse conceito pode não ser trivial à primeira vista, por isso vamos nos debruçar um pouco sobre ele.

A calculadora e o computador têm propósitos diferentes, isso se deve ao fato de que cada um procura resolver um problema diferente.

A calculadora tem por objetivos calcular (nossa, quem diria, né), ou seja, você passa uma conta e ela te devolve um resultado, por exemplo, 5+2, ela devolve 7.

Calculadoras são de uso específico, elas não conseguem executar nenhuma operação que já não esteja implementada em sua arquitetura interna.

O que é um computador?

Um computador é bem diferente de uma calculadora, um computador serve para computar, ou seja, você consegue inserir um conjunto de instruções (o que chamamos de software) a fim de processar sobre uma entrada de dados e transformar em outra saída de dados.

Por exemplo, em um computador, é possível inserir um conjunto de instruções que lê uma entrada de dados e converte em sinal de som.

Todo software de música funciona assim.

Mas computadores não são capazes apenas de tocar música, o ponto central é que um computador é de uso geral e não específico, como uma calculadora.

É por isso que um computador consegue emular uma calculadora, mas uma calculadora não consegue emular um computador.

Computadores não são inteligentes.

Outro erro comum de pessoas leigas no assunto é achar que computadores são inteligentes.

À primeira vista, eu entendo a confusão.

Computadores têm habilidades que podem ser confundidas com inteligência, por exemplo, um computador tem memória superior à de qualquer humano, tanto em tamanho quanto em precisão (ela nunca se altera).

Computadores também conseguem efetuar cálculos matemáticos muito mais rápido que um ser humano normal, algo que pode ser confundido com inteligência.

Por mais que essas coisas chamem atenção, e sejam de fato impressionantes, elas por si só não tornam um computador inteligente.

Para ilustrar melhor, vamos tentar responder à seguinte pergunta: o que é a inteligência?

Essa pergunta é interessante por diversas razões, sendo essencial para levar esse pequeno debate a algum lugar viável.

Apesar de milênios de conhecimento e filosofia acumulados, o ser humano ainda não possui uma definição final do que seja inteligência, então todo e qualquer debate que envolva esse conceito será, no melhor dos casos, de ordem condicional.

Mas para responder à nossa pergunta (se um computador é inteligente ou não), não precisamos ir tão longe, apesar de um computador conter algumas características que parecem inteligência, ele reprova miseravelmente em outras características necessárias à inteligência.

Aqui podemos listar várias delas: autodeterminação, adaptação, etc...

Para facilitar, entenda que um computador sequer consegue resolver todos os problemas matemáticos (pesquise sobre o problema da parada), e por sua vez a matemática não consegue resolver todos os problemas humanos (tente usar matemática para calcular o que é a vida, boa sorte tentando).

A única coisa que realmente me impressiona hoje em dia em um computador é como algo tão efêmero e simples pode ser capaz de feitos impressionantes.

Resposta: por que nós ensinamos isso a ele.

Idiota rápido VS gênio lento

Quero aproveitar esse pequeno debate e fazer uma pequena (mas útil) comparação entre um computador e o cérebro humano.

Os computadores são essencialmente grandes idiotas, mas eles são muito rápidos e obedientes (um excelente idiota), o que os torna muito úteis para resolver diversos problemas triviais.

Já o cérebro humano é essencialmente um gênio, ele é capaz de entender conceitos complexos de forma profunda e possui uma capacidade real de criatividade, mas ele é lento.

Ambos têm o seu valor, portanto é necessário saber quando utilizar o idiota rápido e quando "conversar" com o gênio lento.

Uma pequena dica, o cérebro de modo geral é lento, isso quer dizer que o aprendizado deve ser feito também de forma lenta, portanto paciência é essencial para o bom aprendizado, não adianta pegar atalhos, "natura non facit saltus" (a natureza não dá saltos).

As 5 grandes partes do projeto

Agora estamos prontos para colocar as mãos na massa, mas antes tenho que deixar alguns avisos importantes.

Esse tutorial praticamente não utiliza abstrações, portanto nada de peças prontas ou outras facilidades, usaremos apenas portas lógicas e Flip Flops.

Isto diminui um pouco a carga teórica e aumenta a didática, mas de contrapartida acrescenta o trabalho, por isso reafirmo, esse artigo é para quem quer entender e desenvolver profundamente as bases da computação, e não simplesmente montar um computador.

Sistema de input

Este sistema é onde controlamos a entrada de dados do usuário, os seus componentes são:

sistema clock
sistema de reset
Read Only Memory (ROM)
Control Input Data

Sistema de memória

Aqui é o sistema que gerencia e armazena todos os dados do nosso computador, os seus componentes são:

Memory Address Register (MAR)
Random Access Memory (RAM)

Sistema Lógico e Aritmético

Aqui é onde os dados do sistema são processados, ou seja, é onde eles são transmutados de acordo com a operação escolhida (soma, subtração, etc.), os seus componentes são:

Arithmetic Logic Unit (ULA)
Acumulador (ACC)
Register B

Sistema de saída

Nesta parte do nosso projeto é onde nós convertemos e exibimos os dados que desejamos mostrar ao usuário do nosso computador, os seus componentes são:

Output Register
Converter Binary to Decimal

Sistema de controle

Aqui é a central de operações do nosso computador, todos os sinais do nosso computador são gerenciados aqui, estes são os seus componentes:

Program counter (PC)
Instruction Register (IR)
Controller

Finalização

Se você leu e entendeu até aqui, saiba que você já possui a completa essência deste projeto.

Agora vamos começar a botar a mão na massa e nos aprofundar um pouco mais em cada parte do projeto.

"A partir de um bruto diamante se lapida uma bela joia." Renan Marquetti.

próximo artigo

Agradecimentos

Um agradecimento especial aos meus pais, que me ensinaram a viver, e à minha esposa, que cuida de mim e da nossa família.

Não posso deixar de me esquecer de agradecer a Felipe Rocha Novaes e Sibelius Seraphini, que foram os primeiros a me encorajar a escrever artigos.

Como fazer copy paste com nvim em conexão ssh

Renan Marquetti — Tue, 15 Jul 2025 02:40:38 +0000

Introdução

Recentemente comecei a trabalhar em uma empresa que me forneceu uma maquina remota para trabalho, nós usamos conexão ssh acessar estas maquinas.

Não sou dev raiz, mas gosto de usar nvim (com kickstart), para mim ele simplesmente funciona e é altamente personalizável e leve.

Mas logo nos meus primeiros usos me deparei com um problema, o copy e paste não funcionava como o esperado, queria copiar parte do código colar na minha maquina local, mas simplesmente não funcionava.

Decidi me debruçar sobre o problema, com determinação encontrei uma solução plausível, e aqui busco compartilha-la.

Visão geral

O ponto central do problema (logo da solução também), é que o nvim não tem acesso direto a área de transferência do seu sistema operacional (não importa se é maquina remota ou local), logo é necessário um "intermediário" que o nvim chama de provedor.

Mas nem todo provedor é valido em todos os ambientes, os mais comuns não funcionam em conexões ssh, por sorte um santo escreveu isso na doc do nvim:

Como pode ver existe alguns provedores de área de transferência específicos para conexão ssh, decidi utilizar o lemonade, no qual obtive bons resultados

O lemonade utiliza uma conexão tcp para enviar o conteúdo da sua maquina remota para a sua maquina local, então é necessário alguns cuidados e configurações para tudo funcionar bem

Se tem interesse em utilizar o lemonade basta seguir o guia abaixo

Guia

aviso: este guia parte do pressuposto que estais usando linux tanto na maquina remota quanto na maquina local, embora seja perfeitamente possível adaptar esse guia para usuários de outros sistemas operacionais, já que o lemonade é multi plataforma.

1. Download lemonade release:

escolha a versão desejada (usei 1.1.1)
baixe o arquivo lemonade_linux_amd64.tar.gz na sua maquina local (no meu caso tanto a minha maquina local quanto a minha maquina remota são linux)

se preferir basta rodar o seguinte comando

curl -L -O https://github.com/lemonade-command/lemonade/releases/download/v1.1.1/lemonade_linux_amd64.tar.gz

2. Instale o lemonade na sua maquina local:

descompacte o arquivo obtido no passo anterior
```
tar -zxvf lemonade_linux_amd64.tar.gz
```
a descompactação ira gerar um binário (de nome lemonade) no seu diretoria atual, para ser acessado facilmente pelo sistema (e o terminal), devemos mover para o diretório bin do linux, para isso basta executar
```
mv lemonade /bin
```
(opcional) remova o tar.gz executando o seguinte comando
```
rm lemonade_linux_amd64.tar.gz
```

3. Instale o lemonade na sua maquina remota:

basta copiar o binário da sua maquina local (apenas se for o mesmo sistema operacional), para isso vamos utilizar o comando
```
scp /bin/lemonade usuario@servidor:/bin
```

4. configure o lemonade na sua maquina local:

crie um aquivo no seu .config, chame-o de lemonade.toml, use o seguinte comando
```
nvim ~/.config/lemonade.toml
```

insira o seguinte conteudo

port = 2489
host = 'localhost'
line-ending = 'crlf'

5. configure a sua conexão ssh:

abra o seu arquivo de configuração ssh, no meu caso esta em ~/.ssh/config, para isso execute o seguinte comando
```
nvim ~/.ssh/config
```
insira esta linha
```
RemoteForward 2489 localhost:2489
```

6. configure o lemonade na sua maquina remota:

acesse a sua maquina remota
crie um aquivo no seu .config, chame-o de lemonade.toml, use o seguinte comando
```
nvim ~/.config/lemonade.toml
```

insira o seguinte conteúdo

port = 2489
host = 'localhost'
trans-loopback = true
trans-localfile = true
line-ending = 'crlf'

7. configure o nvim na sua maquina remota:

abra o arquivo init.lua do seu nvim, no meu caso (uso o kickstart), então usei o comando
```
nvim ~/.config/nvim/init.lua
```
verifique se já possue esta configuração, caso não tenha insira
```
vim.schedule(function()
vim.opt.clipboard = 'unnamed'
end)
```
insira esta linha, (cuidado, não pode duplicar essa configuração, insira somente se você não possui esta configuração)
```
vim.g.clipboard = 'lemonade'
```

8. executando:

acesse a sua maquina local
suba o server limonade com o seguinte comando
```
lemonade server
```
acesse a sua maquina remota
abra um arquivo qualquer com o nvim
copie uma linha da sua escolha utilizando o comando
```
"+yy
```
na sua maquina local, faça paste a onde desejar

Alternativa

Considere usar o nvim da sua maquina local conectado a sua maquina remota, para isso basta usar o protocolo scp:

  nvim scp:://user@hostname//path/to/file

Muito obrigado por você que leu até aqui, sabemos o quão árdua é a jornada até a excelência, mas espero ter ajudado em mais um passo, qualquer duvida e sugestão pode entrar em contato comigo direto pelo meu Linkedin

Como fazer find em arrays no mongoDb

Renan Marquetti — Sat, 28 Jun 2025 20:32:17 +0000

Introdução

Esse artigo tem por objetivo ensinar realizar consultas em campos de arrays para collections MongoDb

"Sintaxe JS" vs "Sintaxe mongoDb"

Primeiramente vamos estabelecer a base da nossa didática, para isso vamos supor que você tenha uma array de objetos com a seguinte tipagem:

type Inventory = {
  item: string,
  qty: number,
  tags: Array<string>,
  dim_cm: Array<number>,
}

como você faria para buscar a lista de objetos com menos de 10 itens em estoque? poderia ser feito um filter no array passando como argumento uma arrow function que atende-se tal critério, ficaria algo, mais ou menos assim:

  const queryLessThanTen = obj => obj.qty < 10;
  const myResult = myCollectionArray.filter(queryLessThanTen);

Observe a nossa arrow function na primeira linha, nesse contexto ela se comporta como uma "query", sendo essa a "Sintaxe JS" para buscar dados em um array

o mongo possui a sua própria "sintaxe" de consulta, então se os nossos dados estiverem em uma collection do mongoDb, teriamos que escrever a nossa query da seguinte forma:

  const queryLessThanTen = {qty: {$lt: 10}};
  const myResult = db.collection('inventory').find(queryLessThanTen);

você consegue perceber a diferença? embora as "sintaxes" sejam diferentes, os objetivos são os mesmos, logo obj => obj.qty < 10 é equivalente a {qty: {$lt: 10}}, esta sera a base da nossa didática

Casos de uso

Agora vamos começar a colocar a mão na massa, assim vamos expor os principais casos de uso envolvido quando deseja realizar consultas sobre array em mongoDb, mas cuidado, pode parecer simples a primeira vista, e de fato o é, mas finds sobre arrays esconde uma série de segredos e nuances que vamos começar a expor e trabalhar a partir daqui.

Comparação por igualdade/uniformidade

Caso: contem/inclui valor

const js = i => i.tags.includes("red")
const mongo = {tags: "red"}

este é o mais simples deles, deve ser usado para selecionar todos os documentos que contem um determinado valor dentro do array

Caso: valor index N é igual á

const js = i => i.tags[1] === "red"
const mongo = {'tags.1': "red"}

caso similar ao anterior, mas com uma diferença importante, ele contem uma especificação de index para a consulta.

por exemplo nesse exemplo o array ["blank", "red", "blue"] é valido, porque o valor de index 1 é iqual a "red", mas o array ["red", "blue"] não é valido, porque o valor de index 1 ("blue") é diferente de "red".

Caso: idêntico/exato

const js = i => i.tags.toString() == ["red", "blank"].toString()
const mongo = {tags: ["red", "blank"]}

este caso é similar ao primeiro caso, mas esconde um segredo, deve ser usado somente quando deseja buscar documentos com correspondência exata de valores, incluindo a ordem estabelecida na consulta.

por exemplo, quando se utiliza a correspondência exata um documento que contem o array ["blank", "red"] não corresponde exatamente ao array ["red", "blank"], isso porque contem todos os valores mas a ordem dos não corresponde.

Caso: contem/inclui um conjunto de valores

const js = i => i.tags.includes("red") && i.tags.includes("blank")
const mongo = {tags: { $all: ["red", "blank"]}}

similar o caso acima, mas com uma diferença crucial, aqui usamos o operador $all, ele faz com que os valores não precisam estar na ordem pré estabelecida, portanto nessa consulta os arrays ["blank", "red"] e ["red", "blank"] são equivalentes.

outro ponto a ser observado, nesse tipo de consulta não é levado em conta outros valores do array, logo então o array ["blank", "blue", "red"] também corresponde ao array ["red", "blank"], isso porque os demais valores são irrelevantes para a consulta.

Caso: Tamanho Array

const js = i => i.tags.length == 3
const mongo = {tags: {$size: 3}}

este caso é bem simples, usamos o operador $size para simplesmente compara os tamanhos do array, portanto os arrays: [true, true, false], [1, 2, 3] , ["red", "blank", "blue"] são equivalentes.

Comparação por referencia/relativa

Caso: contem/inclui valor maior que

const js = i => i.dim_cm.findIndex(d => d > 25) > -1
const mongo = {dim_cm: {$gt: 25}}

neste caso busca todos os documentos que contem ao menos um valor numérico maior que 25.

também pode ser utilizado o comparador {$lt: 25} (less than), para buscar valor menor que 25.

Caso: contem/inclui valor maior que e valor menor que

const js = i => i.dim_cm.findIndex(d => d > 15) > -1 && i.dim_cm.findIndex(d => d < 20) > -1
const mongo = {dim_cm: {$gt: 15, $lt: 20}}

está consulta deve ser usada quando busca um array que contem algum valor maior que 15 e algum valor menor do que 15, nesse caso o array contendo os valores [25, 10] é valido para a consulta.

este caso contem uma importante nuance, caso o array contenha algum valor que atende ambas as condições, como por exemplo o array [18, 23] é um array valido, porque o valor 18 atende ambas as condições, sendo assim o valor 23 é irrelevante para a consulta.

Caso: contem/inclui valores maior que e menor que

const js = i => i.dim_cm.findIndex(d => d > 22 && d < 30) > -1
const mongo = {dim_cm: {$elemMatch: {$gt: 22, $lt: 30}}

similar o caso acima, com uma diferença, aqui usamos o operador $elemMatch, ele faz com que todas as comparações se apliquem em todos os elementos do array.

por exemplo nessa consulta o array [25, 29] é valido, porque tanto 25 quanto 29 é maior que 22 e menor que 29.

já o array [25, 32] não é valido, porque 25 atende ambas as comparações, mas 32 atende apenas uma delas, sendo assim a comparação é invalida

Casos compostos

Também é possível combinar diversos casos e operadores para buscar um resultado mais especifico, seria um trabalho hercúleo expor todas as possibilidades, logo vamos exemplificar apenas alguns deles

Caso: tamanho de array e inclui conjunto de valores

const js = i => i.tags.length == 2 && i.tags.includes("red") && i.tags.includes("black")
const mongo = {tags: {$size: 2, $all: ["red", "black"]}}

este exemplo utiliza a junção dos operadores $size e $all, deve ser usado quando deseja buscar documentos cujo array tenha apenas o conjunto de valores passado como paramentos, mas sem se importar com a ordem dos valores.

por exemplo nesse caso os arrays ["red", "black"] e ["blank", "red"] são equivalentes, mas o array ["red", "black", "blue"] agora não é mais equivalente, isso porque a presença do valor "blue" passa a ser relevante para a comparação.

em resumo, utilize esse caso quando deseja buscar arrays por uniformidade, sem exatidão.

Caso: contem/inclui valores maior que e menor que e algum valor igual á

const js = i => i.dim_cm[0] == 26 && i.dim_cm.findIndex(d => d > 22 && d < 30) > -1
const mongo = {dim_cm: {'dim_cm.0': 26, $elemMatch: {$gt: 22, $lt: 30}}}

unindo o operador $elemMatch e a busca por index, é possível filtrar ainda mais os dados, nesse caso sera retornado os arrays em que todos os valores são maior do que 22 e menor do que 30, mas desde que o primeiro valor seja 26.

por exemplo os arrays: [26], [26, 29], [26, 25, 27] são equivalentes, mas os arrays [23], [27, 29], [28, 25, 27] não são equivalentes.

isso porque todos os valores satisfazem a primeira regra, mas não satisfaz a ultima regra em que exige que o primeiro valor seja igual a 26.

Repositorio

caso tenha interesse faça um fork desse repositório, e execute na sua maquina, ele contem uma série de teste com todos esses exemplos, isto vai agilizar e profundar ainda mais o seu conhecimentos sobre o assunto.

Agradecimentos

muito obrigado por você que leu até aqui, quero agrade-lo pela sua atenção e dedicação, qualquer duvida ou sugestão ou critica por favor entre em contato comigo através do meu linkedin

Como mapas de Karnough podem te transformar em um programador melhor.

Renan Marquetti — Sat, 03 May 2025 15:13:20 +0000

Este artigo busca demonstrar a importância da base.

Introdução

Sou um desenvolvedor com pouco tempo de jornada (cerca de 1 ano), mas desde o começo dos meus estudos me interessei pelos conceitos base da computação, sempre quis saber como as coisas realmente funcionam por baixo dos panos, sem abstrações.

Apesar de gostar e me interessar pela base, nunca consegui me debruçar sobre o estudo da mesma, mas isso começou a mudar quando encontrei a UBL, uma faculdade inteira sobre ciências da computação e de código aberto, recebi como um grande presente, enviado dos céus.

Logo no começo (cerca de 2 semanas) tive os meus primeiros espantos, pensei que levaria meses para que aquele estudo começa-se a fazer algum efeito, que fosse capaz de mudar a forma programar.

Já na matéria de circuitos digitais (primeira matéria), alguns conceitos me chamaram atenção pela sua simplicidade e genialidade, especialmente mapas de Karnough.

Então, nada mais natural que buscar uma forma de implementa-lo em um ambiente de desenvolvimento.

Mapas de Karnough
Nesta sessão quero demonstrar uma possível aplicação para mapas de Karnough em um ambiente de desenvolvimento, para um melhor aproveitamento do corrente artigo é necessário que o leitor já tenha algum contado com o conceito, caso queria saber o que é mapas de Karnough recomendo que veja: Artigo Mapas de Karnough.

Para exemplificar melhor, imagine a seguinte situação, você é um desenvolvedor prestando consultoria para uma montadoras de veiculo que precisa fazer um recall.

Solicitam que você levante as informações para montar um relatório para saber em quais carros a peça se encontra, você se depara com uma base de dados completamente desorganizada (é raro, mas acontece sempre), sendo necessário uma busca indireta.

Você solicita ao time de engenheiros que passem os critérios para uso da peça, você recebe a seguinte lista:

foi usada em carros que são vermelhos e não são do ano atual e o nome não começa com a letra 'V'.
foi usada em carros que são vermelhos e são do ano atual e o nome não começa com a letra 'V'.
foi usada em carros que não são vermelhos nem são do ano atual e podem ou não começar com a letra 'V'.
foi usada em carros que são vermelhos e não são do ano atual e o nome começa com a letra 'V'.

Você pode estar pensando que é simples resolver o problema, basta isolar cada critério dentro de uma expressão booleana e unir tudo no final com o operador "ou", ficando algo mais ou menos assim:

    const cars = [...terabytesOfData];
    const carsFilter = cars.filter(c => {
        const A = c.isRed(); 
        const B = c.isCurrentYear(); 
        const C = c.isStartsV();

        return (A && !B && !C) || (A && B && !C) || 
               (!A && !B) || (A && !B && C);
    });

Isso funciona, até você ver que o banco tem terabytes de dados para serem analisados e filtrados, logo o otimização aqui é necessário, mas como faze-la de forma confiável, neste momento que entra em cena o mapa de Karnough.

Existem diversas ferramentas online para isso, aqui vamos usar o site Make Hero (a ferramenta se encontra na metade do artigo)

Para usa-la basta seguir os seguintes passos:

1 - isole as variáveis booleanas dentro de cada critério, neste caso temos 3 variáveis:

        A = car.isRed();
        B = car.isCurrentYear();
        C = car.isStartsV();

2 - agora preencha a tabela verdade com o resultado de cada critério, (1 para sim e 0 para não), por exemplo, o primeiro critério ficaria A = 1, B = 0, C = 0, agora procure a linha que corresponde a esse critério (linha 5), e maque 1, repita o processo até terminar todos os critérios, ficado assim:

3 - pegue e utilize a expressão resultante, no nosso caso é !B || (A && !C)

    // before: 
    return (A && !B && !C) || (A && B && !C) || 
           (!A && !B) || (A && !B && C);
    // after: 
    return !B || (A && !C);

4 - se preferir converta para uma expressão legível para humanos, no nosso caso ficaria assim: a peça foi usada em carros que não são do ano ou que são vermelhos e não começam com a letra 'V'.

Pode parecer pouco, mas conseguimos reduzir de 4 critérios para 1, uma economia de 75%, algo decisivo em alguns projetos, e o melhor de tudo, é matematicamente segura.

se você leu até aqui, você é um herói da resistência, então por favor eu gostaria de ouvir o seu feedback, caso tenha interesse, segue o meu linkedin: Renan Marquetti