Olá todo mundo, este é o terceiro artigo na série sobre computadores, e também o último com esse cabeçalho aqui, pois daqui para a frente é recomendado que você já tenha lido os dois artigos anteriores:

• Portas lógicas.
• Prazer, Binário..

Nos artigos anteriores, nós vimos como portas lógicas podem ser usadas para fazer comparações e também calcular operações aritméticas, porém ainda não vimos como o computador pode guardar uma informação ao longo do tempo.

Outra coisa que também iremos fazer aqui é categorizar cada tipo de chip: os que foram mostrados anteriormente são combinacionais, o que significa que eles não precisam de nada além de sinais nas suas entradas para poder computar um resultado, mas existem também os sequenciais. A diferença entre eles é que o sequencial depende não só dos sinais das entradas, mas também do valor anteriormente processado.

Um jeito muito prático de usar portas lógicas para guardar informações é usando um chip chamado de flip-flop, que está representado abaixo. Ele contém 2 entradas: a de cima set e a de baixo reset (você pode clicar no circuito abaixo para interagir com eles).

Interactive circ widget — view it on the blog.

╭───────╮     ╭───╮           ╭───╮     ╭───╮
│ reset ├○───▶┤NOT├○╮     ╭──▶┤   │ ╭──▶┤LED│
╰───────╯     ╰───╯ │     │   │AND├○●   ╰───╯
                    ╰─────┼──▶┤   │ │        
                          │   ╰───╯ │        
            ╭─────────────┼─────────╯        
╭─────╮     │ ╭─────────╮ │                  
│ set ├○╮   ╰▶┤         │ │                  
╰─────╯ │     │[or:_or_]├○╯                  
        ╰────▶┤         │                    
              ╰─────────╯                    

Se parar para analisar, é bem simples: seguindo a trilha do set, verá que há duas portas lógicas no caminho, uma OR e uma AND. Uma das entradas da porta OR está ligada com o resultado da AND lá no fim do chip. Essa combinação faz com que, quando temos 0 e é nos dado um valor 1, a porta OR vai resultar em 1, e a AND também.

Porém, quando removemos o sinal do set, o valor que foi anteriormente colocado é persistido porque agora o OR está mantendo o estado que mantém o AND também no estado anterior. Problema resolvido, certo? Não! Perceba que nosso circuito agora está travado, pois não há como sair desse estado a não ser que o AND passe a ter um outro valor, e é para isso que serve a porta reset: ela está ligada a um NOT, ou seja, enquanto ela estiver desligada (0), o seu resultado vai ser 1 (ligado), e vice-versa.

Uma evolução que podemos fazer no flip-flop é transformá-lo em um Registrador. No registrador, podemos escolher se é ou não a hora de ler o nosso sinal e guardá-lo, e subsequentemente reescrevê-lo, e tudo isso ao nosso bel-prazer. Existem muitas formas de atingir esse chip, então vou usar a implementação demonstrada pelo Sebastian Lague.

Nela, a gente só precisa adicionar mais 3 portas lógicas e pronto!

Interactive circ widget — view it on the blog.

╭──────╮        ╭───╮     ╭───╮     ╭───╮     ╭───╮     ╭───╮     ╭───╮     ╭───╮     ╭───╮
│ data ├○──●───▶┤   │  ╭─▶┤NOT├○┬──▶┤NOT├○───▶┤   │ ╭──▶┤NOT├○╮ ╭▶┤   │ ╭──▶┤NOT├○●──▶┤LED│
╰──────╯   │    │AND├○─╯  ╰───╯ │   ╰───╯     │AND├○╯   ╰───╯ │ │ │AND├○╯   ╰───╯ │   ╰───╯
           │╭──▶┤   │           │           ╭▶┤   │           ╰─┼▶┤   │           │        
           ││   ╰───╯           │           │ ╰───╯             │ ╰───╯           │        
           ││                   ├───────────┼───────────────────╯                 │        
╭─────────╮││   ╭───╮     ╭───╮ │           │                                     │        
│ enabled ├○┼──▶┤NOT├○───▶┤   │ │           ╰─────────────────────────────────────╯        
╰─────────╯ │   ╰───╯     │AND├○╯                                                          
            ╰────────────▶┤   │                                                            
                          ╰───╯                                                            

Se a gente destrinchar um pouco, o que acontece é o seguinte: a entrada superior, que agora chamaremos de data, só será salva no flip-flop quando a entrada inferior, que também mudou o nome, agora se chama enabled. Ou seja, em vez de usar duas entradas, uma para salvar e outra para apagar, essa combinação de ANDs e NOT escolhe qual operação será feita.

• Se data = 1 e enabled = 1, então é a mesma coisa que ligar a entrada set do flip-flop.
• Se data = 0 e enabled = 1, então é a mesma coisa que ligar a entrada reset do flip-flop. Perceba que o enabled precisa sempre estar ativado para que possa salvar o sinal que foi colocado em data.

Uma outra coisa que podemos fazer é pegar inspiração no artigo anterior, que no final a gente aprende que, se juntarmos vários Adders, nós podemos fazer contas com múltiplos dígitos. Na memória é do mesmo jeito: juntando vários registradores, você pode fornecer uma entrada para cada data e compartilhar o sinal do enabled, e assim você pode salvar os valores de um número binário inteiro.

Por enquanto, a gente se despede por aqui, até a próxima 😄

Referências

• How Do Computers Remember? (YouTube)
• SR latch (YouTube)
• D latch
• HOW TRANSISTORS RUN CODE? (YouTube)
• From Nand to Tetris

Hey Y’all! This is a translation of my blog post originally written in Portuguese.

Hello everyone, this is the third article in the series about computers, and also the last one with this header here, because from here on it’s recommended that you have already read the two previous articles:

• Logic gates.
• Pleasure to meet you, Binary..

In the previous articles, we saw how logic gates can be used to make comparisons and also calculate arithmetic operations, but we haven’t yet seen how the computer can store information over time.

Another thing we’ll do here is categorize each type of chip: the ones shown previously are combinational, which means they don’t need anything beyond signals at their inputs to be able to compute a result, but there are also sequential ones. The difference between them is that sequential depends not only on the input signals, but also on the previously processed value.

A very practical way to use logic gates to store information is using a chip called flip-flop, which is represented below. It contains 2 inputs: the top one set and the bottom one reset (you can click on the circuit below to interact with them).

Interactive circ widget — view it on the blog.

╭───────╮     ╭───╮           ╭───╮     ╭───╮
│ reset ├○───▶┤NOT├○╮     ╭──▶┤   │ ╭──▶┤LED│
╰───────╯     ╰───╯ │     │   │AND├○●   ╰───╯
                    ╰─────┼──▶┤   │ │        
                          │   ╰───╯ │        
            ╭─────────────┼─────────╯        
╭─────╮     │ ╭─────────╮ │                  
│ set ├○╮   ╰▶┤         │ │                  
╰─────╯ │     │[or:_or_]├○╯                  
        ╰────▶┤         │                    
              ╰─────────╯                    

If you stop to analyze, it’s quite simple: following the set trail, you’ll see there are two logic gates in the path, an OR and an AND. One of the OR gate inputs is connected to the result of the AND at the end of the chip. This combination makes it so that when we have 0 and are given a value 1, the OR gate will result in 1, and the AND will also.

However, when we remove the signal from set, the value that was previously placed is persisted because now the OR is maintaining the state that keeps the AND also in the previous state. Problem solved, right? No! Notice that our circuit is now locked, as there’s no way to get out of this state unless the AND gets another value, and that’s what the reset gate is for: it’s connected to a NOT, meaning while it’s off (0), its result will be 1 (on), and vice versa.

An evolution we can make to the flip-flop is to transform it into a Register. In the register, we can choose whether it’s time or not to read our signal and store it, and subsequently rewrite it, all at our leisure. There are many ways to achieve this chip, so I’ll use the implementation demonstrated by Sebastian Lague.

In it, we just need to add 3 more logic gates and that’s it!

Interactive circ widget — view it on the blog.

╭──────╮        ╭───╮     ╭───╮     ╭───╮     ╭───╮     ╭───╮     ╭───╮     ╭───╮     ╭───╮
│ data ├○──●───▶┤   │  ╭─▶┤NOT├○┬──▶┤NOT├○───▶┤   │ ╭──▶┤NOT├○╮ ╭▶┤   │ ╭──▶┤NOT├○●──▶┤LED│
╰──────╯   │    │AND├○─╯  ╰───╯ │   ╰───╯     │AND├○╯   ╰───╯ │ │ │AND├○╯   ╰───╯ │   ╰───╯
           │╭──▶┤   │           │           ╭▶┤   │           ╰─┼▶┤   │           │        
           ││   ╰───╯           │           │ ╰───╯             │ ╰───╯           │        
           ││                   ├───────────┼───────────────────╯                 │        
╭─────────╮││   ╭───╮     ╭───╮ │           │                                     │        
│ enabled ├○┼──▶┤NOT├○───▶┤   │ │           ╰─────────────────────────────────────╯        
╰─────────╯ │   ╰───╯     │AND├○╯                                                          
            ╰────────────▶┤   │                                                            
                          ╰───╯                                                            

If we break it down a bit, what happens is the following: the upper input, which we’ll now call data, will only be saved in the flip-flop when the lower input, which also changed names, now called enabled. So instead of using two inputs, one to save and another to erase, this combination of ANDs and NOT chooses which operation will be performed.

• If data = 1 and enabled = 1, then it’s the same as turning on the set input of the flip-flop.
• If data = 0 and enabled = 1, then it’s the same as turning on the reset input of the flip-flop. Notice that enabled always needs to be activated so that it can save the signal that was placed in data.

Another thing we can do is take inspiration from the previous article, where at the end we learned that if we combine several Adders, we can do calculations with multiple digits. In memory it’s the same way: combining several registers, you can provide an input for each data and share the enabled signal, and thus you can save the values of an entire binary number.

For now, we say goodbye here, see you next time 😄

References

• How Do Computers Remember? (YouTube)
• SR latch (YouTube)
• D latch
• HOW TRANSISTORS RUN CODE? (YouTube)
• From Nand to Tetris

Olá pessoas dessa internet, para quem está chegando aqui agora, este é o segundo artigo de uma série que estou fazendo para falar sobre os fundamentos da computação, recomendo ler o primeiro sobre portas lógicas. E para quem já leu o primeiro artigo, dá um pulinho lá porque eu fiz uma revisão no artigo, recomendo bastante dar uma olhada 😊

Vamos nos aprofundar um pouco mais e explorar alguns conceitos de matemática e também da história humana.

A matemática veio da necessidade de contar e medir da raça humana – quantos animais a Maria cuida, quantos dias até o próximo solstício… Com o tempo e a expansão humana, povos antigos criaram vários sistemas de numeração para o seu dia a dia. Jogos como Grand Theft Auto V, Call of Duty: Black Ops III, Dragon Quest XI são exemplos de uso do sistema numeral que os romanos usavam, e o I Ching, um antigo texto chinês, tem raízes em representações binárias.

Porém, não somente as antigas civilizações usavam outros sistemas numéricos. As horas de um dia são divididas entre 12 horas do período da manhã e 12 horas do período da tarde, ou uma dúzia de ovos. Na língua francesa ainda existem resquícios de um sistema com base vigesimal (20), por exemplo, o número 80 se diz quatre-vingts (quatro vintes), e um dos mais recentes é o Braille, que também tem raízes em representações binárias.

Nos dias atuais, utilizamos a representação decimal, e o motivo é bem simples: a média de dedos em mãos humanas são incríveis 10 dedos, sendo assim fica mais fácil contar usando somente as mãos.

☝️ + ☝️ = ✌️

Essa representação em base 10 é posicional, ou seja, a posição em que os dígitos são “desenhados” muda a quantidade que se está representando. 70 representa dez vezes mais que 07, daí vem o ditado popular “zero à esquerda”. Na escola, aprendemos as casas decimais – unidades, dezenas, centenas… Elas servem para representar qual é a posição desse dígito.

E em cima dessa ordem existe uma fórmula matemática que converte um número de qualquer base para decimal. Para facilitar:

• Dígito: Símbolo que representa uma quantidade única.   Ex.: 1, 2, 3, 4, 5, 6, 7, 8, 9, 0
• Número: Dígitos organizados em ordem de posição.   Ex.: 10, 144, 999, 42, 37, 0x8A6C, 0b101010
• Base: Quantidade máxima de dígitos que pode ser representada.   Ex.: binário (0b) 2, decimal 10, hexadecimal (0x)
• Índice: A magnitude do dígito na posição.   _Ex.: 10, o 1 em 10 tem Índice 1 e o 0 tem Índice 0 (é meio contraintuitivo, mas faz sentido).   Em outras palavras, o índice é a posição da direita para a esquerda, começando em 0.

A fórmula é bem simples: (d)ígito × (b)ase^(i)ndice. No exemplo que estamos fazendo, esta é a fórmula para converter 70 em decimal… para 70 em decimal. 7 × 10¹ + 0 × 10⁰ = 70

Interactive binary counter widget (base 10, 3 digits) — view it on the blog.

Quando falamos de números dessa forma, fica mais fácil representar o binário, que nada mais é que a quantidade que pode ser representada pela fórmula d × 2ⁱ.

Interactive binary counter widget (base 2, 6 digits) — view it on the blog.

E essa forma de representar quantidades também pode ser manipulada com operações matemáticas. A adição 25 + 17 é resolvida de modo parecido com isso.

1
2 5
1 7
--- +
4 2

No exemplo acima, temos alguns elementos que precisam ser destacados:

1. Um dígito só pode ser somado com outro dígito que estiver no mesmo índice.
2. Quando a soma não puder ser representada com apenas um dígito, o menor índice é mantido como resultado, e o resto é enviado para o próximo índice.
3. O resultado de uma soma será sempre a soma dos dígitos do índice + o resto que veio do dígito no índice anterior.

Com esses mesmos passos, podemos aplicar a soma em qualquer base.

    1 1 1       |  1      |  
1 0 0 0 1 1     |  2 5    |  1 9
0 0 0 1 1 1     |  1 7    |  1 1
------------ +  |  --- +  |  --- +
1 0 1 0 1 0     |  4 2    |  2 A 

Interactive binary counter widget (base 2, 6 digits) — view it on the blog.

Agora que já nos conhecemos, como podemos fazer para o computador nos conhecer também?

Brincando de tradução

Lembrando do artigo anterior, vamos isolar a soma de dois dígitos em tabelas. A primeira, vamos olhar para o resultado apenas. Temos esta tabela que se assemelha muito com a tabela da porta OR, exceto por essa pequena mudança no final.

Para isso, podemos combinar o resultado das portas que já vimos anteriormente em um só circuito chamado “OU Exclusivo” ou “XOR”.

Interactive circ widget — view it on the blog.

╭───╮     ╭─────────────╮     ╭───╮     ╭───╮
│ a ├○●●─▶┤             │╭───▶┤   │ ╭──▶┤LED│
╰───╯ ││  │[nand:_nand_]├○╮   │AND├○╯   ╰───╯
      │●─▶┤             ││╰──▶┤   │          
      ││  ╰─────────────╯│    ╰───╯          
      ││                 │                   
╭───╮ ││  ╭─────────╮    │                   
│ b ├○●╰─▶┤         │    │                   
╰───╯ │   │[or:_or_]├○───╯                   
      ╰──▶┤         │                        
          ╰─────────╯                        

Agora, vamos olhar também para a tabela do resto da nossa soma e se percebe que é uma cópia exata da porta AND.

E assim como o Capitão Planeta, “Pela união dos seus poderes”, nós vamos conseguir fazer a operação de soma de dois dígitos em binário, e esse componente é chamado de “Somador” ou “Adder”.

Interactive circ widget — view it on the blog.

╭───╮        ╭───╮               ╭───╮               ╭─────────╮     ╭───╮
│ a ├○●●────▶┤   │           ╭──▶┤   │ ╭────────────▶┤         │ ╭──▶┤LED│
╰───╯ ││     │AND├○╮         │   │AND├○╯             │[or:_or_]├○╯   ╰───╯
      │●────▶┤   │ │         │ ╭▶┤   │             ╭▶┤         │          
      ││     ╰───╯ │         │ │ ╰───╯             │ ╰─────────╯          
      ││           ╰─────────┼─┼───────────────────╯                      
╭───╮ ││     ╭─────────────╮ │ │ ╭─────────────╮                     ╭───╮
│ b ├○●╰────▶┤             │ ●─┼▶┤             │ ╭──────────────────▶┤LED│
╰───╯ │      │[xor:_xor_1_]├○● │ │[xor:_xor_2_]├○╯                   ╰───╯
      ╰─────▶┤             │   ●▶┤             │                          
             ╰─────────────╯   │ ╰─────────────╯                          
                               │                                          
╭──────╮                       │                                          
│ c_in ├○──────────────────────●                                          
╰──────╯                                                                  

Com essa combinação de portas lógicas, um computador já consegue fazer as incríveis somas de: 0 + 0, 1 + 0, 0 + 1, 1 + 1, mas, além disso, ele consegue também dizer quanto que houve de resto da soma. E quando combinados vários ADDERs, a gente consegue fazer uma soma de números mais complexos como o 42, mas essa nós vamos ver no próximo artigo.

Por hoje é só isso, pessoal.

Referências

• A brief history of numerical systems (Youtube)
• Numeral system (Wikipédia)
• Sistema de numeração (Wikipédia)
• Exploring How Computers Work (YouTube)
• Making logic gates from transistors (YouTube)
• HOW TRANSISTORS RUN CODE? (YouTube)
• From Nand to Tetris

Hey Y’all! This is a translation of my blog post originally written in Portuguese.

Hello people of this internet, for those who are arriving here now, this is the second article of a series I’m doing to talk about the fundamentals of computing, I recommend reading the first one about logic gates. And for those who have already read the first article, take a quick look there because I did a revision of the article, I highly recommend taking a look 😊

Let’s dive a bit deeper and explore some concepts of mathematics and also human history.

Mathematics came from the human race’s need to count and measure – how many animals Maria takes care of, how many days until the next solstice… Over time and human expansion, ancient peoples created various numbering systems for their daily lives. Games like Grand Theft Auto V, Call of Duty: Black Ops III, Dragon Quest XI are examples of using the numeral system that the Romans used, and the I Ching, an ancient Chinese text, has roots in binary representations.

However, not only ancient civilizations used other numerical systems. The hours of a day are divided between 12 hours of the morning period and 12 hours of the afternoon period, or a dozen eggs. In the French language, there are still remnants of a vigesimal-based system (20), for example, the number 80 is said as quatre-vingts (four twenties), and one of the most recent is Braille, which also has roots in binary representations.

Nowadays, we use decimal representation, and the reason is quite simple: the average number of fingers on human hands is an incredible 10 fingers, so it’s easier to count using only hands.

☝️ + ☝️ = ✌️

This base 10 representation is positional, meaning the position in which the digits are “drawn” changes the quantity being represented. 70 represents ten times more than 07, hence the popular saying “zero to the left”. In school, we learn about decimal places – units, tens, hundreds… They serve to represent what the position of that digit is.

And on top of this order, there’s a mathematical formula that converts a number from any base to decimal. To make it easier:

• Digit: Symbol that represents a unique quantity. Ex.: 1, 2, 3, 4, 5, 6, 7, 8, 9, 0
• Number: Digits organized in order of position. Ex.: 10, 144, 999, 42, 37, 0x8A6C, 0b101010
• Base: Maximum quantity of digits that can be represented. Ex.: binary (0b) 2, decimal 10, hexadecimal (0x)
• Index: The magnitude of the digit in the position. _Ex.: 10, the 1 in 10 has Index 1 and the 0 has Index 0 (it’s a bit counterintuitive, but it makes sense). In other words, the index is the position from right to left, starting at 0.

The formula is quite simple: (d)igit × (b)ase^(i)ndex. In the example we’re doing, this is the formula to convert 70 to decimal… to 70 in decimal. 7 × 10¹ + 0 × 10⁰ = 70

Interactive binary counter widget (base 10, 3 digits) — view it on the blog.

When we talk about numbers this way, it becomes easier to represent binary, which is nothing more than the quantity that can be represented by the formula d × 2ⁱ.

Interactive binary counter widget (base 2, 6 digits) — view it on the blog.

And this way of representing quantities can also be manipulated with mathematical operations. The addition 25 + 17 is solved in a way similar to this.

1
2 5
1 7
--- +
4 2

In the example above, we have some elements that need to be highlighted:

1. A digit can only be added to another digit that is in the same index.
2. When the sum cannot be represented with just one digit, the smallest index is kept as the result, and the remainder is sent to the next index.
3. The result of a sum will always be the sum of the digits of the index + the remainder that came from the digit in the previous index.

With these same steps, we can apply addition in any base.

    1 1 1       |  1      |  
1 0 0 0 1 1     |  2 5    |  1 9
0 0 0 1 1 1     |  1 7    |  1 1
------------ +  |  --- +  |  --- +
1 0 1 0 1 0     |  4 2    |  2 A 

Interactive binary counter widget (base 2, 6 digits) — view it on the blog.

Now that we already know each other, how can we make the computer know us too?

Playing with translation

Remembering the previous article, let’s isolate the addition of two digits in tables. First, let’s look at just the result. We have this table that very much resembles the OR gate table, except for this small change at the end.

For this, we can combine the results of the gates we saw earlier into a single circuit called “Exclusive OR” or “XOR”.

Interactive circ widget — view it on the blog.

╭───╮     ╭─────────────╮     ╭───╮     ╭───╮
│ a ├○●●─▶┤             │╭───▶┤   │ ╭──▶┤LED│
╰───╯ ││  │[nand:_nand_]├○╮   │AND├○╯   ╰───╯
      │●─▶┤             ││╰──▶┤   │          
      ││  ╰─────────────╯│    ╰───╯          
      ││                 │                   
╭───╮ ││  ╭─────────╮    │                   
│ b ├○●╰─▶┤         │    │                   
╰───╯ │   │[or:_or_]├○───╯                   
      ╰──▶┤         │                        
          ╰─────────╯                        

Now, let’s also look at the remainder table of our addition and you’ll notice that it’s an exact copy of the AND gate.

And just like Captain Planet, “By the union of their powers”, we will be able to perform the operation of adding two digits in binary, and this component is called “Adder”.

Interactive circ widget — view it on the blog.

╭───╮        ╭───╮               ╭───╮               ╭─────────╮     ╭───╮
│ a ├○●●────▶┤   │           ╭──▶┤   │ ╭────────────▶┤         │ ╭──▶┤LED│
╰───╯ ││     │AND├○╮         │   │AND├○╯             │[or:_or_]├○╯   ╰───╯
      │●────▶┤   │ │         │ ╭▶┤   │             ╭▶┤         │          
      ││     ╰───╯ │         │ │ ╰───╯             │ ╰─────────╯          
      ││           ╰─────────┼─┼───────────────────╯                      
╭───╮ ││     ╭─────────────╮ │ │ ╭─────────────╮                     ╭───╮
│ b ├○●╰────▶┤             │ ●─┼▶┤             │ ╭──────────────────▶┤LED│
╰───╯ │      │[xor:_xor_1_]├○● │ │[xor:_xor_2_]├○╯                   ╰───╯
      ╰─────▶┤             │   ●▶┤             │                          
             ╰─────────────╯   │ ╰─────────────╯                          
                               │                                          
╭──────╮                       │                                          
│ c_in ├○──────────────────────●                                          
╰──────╯                                                                  

With this combination of logic gates, a computer can already perform the incredible additions of: 0 + 0, 1 + 0, 0 + 1, 1 + 1, but beyond that, it can also say how much remainder there was from the addition. And when several ADDERs are combined, we can perform addition of more complex numbers like 42, but that we’ll see in the next article.

That’s all for today, folks.

References

• A brief history of numerical systems (Youtube)
• Numeral system (Wikipédia)
• Sistema de numeração (Wikipédia)
• Exploring How Computers Work (YouTube)
• Making logic gates from transistors (YouTube)
• HOW TRANSISTORS RUN CODE? (YouTube)
• From Nand to Tetris

Revisado [11/12/2024]

Oi pessoal, então tive que fazer umas mudanças aqui no post pra adicionar alguns widgets interativos, e aproveitei para dar um pouco mais de contexto ao conteúdo.

Olá, este é o primeiro artigo de uma série sobre os fundamentos da computação. A ideia é demonstrar de forma simples e prática como este dispositivo transforma zeros e uns em praticamente qualquer coisa, o funcionamento das CPUs e outros assuntos interessantes. Então, para começar, o primeiro conceito que temos que aprender é o de portas lógicas: elas são a base de toda a computação, com elas podemos fazer certas operações que recebem como entrada um ou mais valores e terão outro valor como resultado.

Mas o que são esses valores? O número 42? O nome da minha mãe? Esses “valores” são energia, mais especificamente a presença e ausência dela. Como foi falado na introdução, computadores funcionam utilizando dígitos binários, ou seja, essas máquinas só entendem 0 e 1 ou “Tem energia” e “Não tem energia”. No entanto, não iremos chamar esses zeros e uns de energia, para o computador eles são sinais.

Quando sinais são combinados e/ou comparados, nós chamamos de operação lógica, por exemplo.

“[Sons de harpa de inicio de história]”

Um dia você contrata uma empresa de elétrica para instalar dois interruptores em um corredor da sua casa, mas, por um erro de desenho, a instalação acaba ficando da seguinte forma: o fio passa pelo primeiro interruptor (vamos chamar de interruptor A), vai direto para o segundo interruptor (B para os íntimos) e, em seguida, sai para a lâmpada.

Reparou que a lâmpada só acende se os dois interruptores estiverem ligados ao mesmo tempo? Se qualquer um deles for desligado, a luz apaga na hora! Pois é, essa atrocidade da elétrica residencial pode ser explicada, na matemática, a partir de um de seus ramos chamado de álgebra booleana, e nela podemos demonstrar isso com uma tabela:

Escrevendo isso de outro modo fica assim:

Se você percebeu bem, agora temos um jeito de representar o que queremos que aconteça com dois interruptores e uma lâmpada, e esse exemplo mostrado acima é a primeira porta lógica que estamos conhecendo, o AND ou Conjunção, e essa tabela, demonstrada acima de formas diferentes, se chama Tabela-Verdade.

Ok, mas e a luz da minha casa? Como que vai ficar? Eu preciso que a luz acenda quando o A OU B estiverem ligados. Como que faz isso?

A resposta está na própria pergunta! 😉 Vamos precisar de uma outra porta lógica, a OR ou Disjunção, e para entender como ela funciona, vamos usar uma tabela-verdade que se encaixe nessas condições:

Mas antes de falar da OR, vamos dar uma olhada na porta NOT (ou Negação). Ela é bem simples, mas vai ser importante mais pra frente.

Interactive circ widget — view it on the blog.

╭───╮     ╭───╮     ╭───╮
│ a ├○───▶┤NOT├○───▶┤LED│
╰───╯     ╰───╯     ╰───╯

E se escrevermos ela numa tabela verdade teremos isso aqui:

Então, vamos fazer uma pausa e revisar o que a gente já sabe. Primeiro, as operações e como representá-las numa tabela. Para simplificar, vamos transformar essas operações em símbolos. Toda vez que nos referirmos ao AND, este será o símbolo:

Interactive circ widget — view it on the blog.

╭───╮     ╭───╮     ╭───╮
│ a ├○───▶┤   │ ╭──▶┤LED│
╰───╯     │AND├○╯   ╰───╯
       ╭─▶┤   │          
       │  ╰───╯          
       │                 
╭───╮  │                 
│ b ├○─╯                 
╰───╯                    

e o NOT:

Interactive circ widget — view it on the blog.

╭───╮     ╭───╮     ╭───╮
│ a ├○───▶┤NOT├○───▶┤LED│
╰───╯     ╰───╯     ╰───╯

Com essas duas operações lógicas (AND e NOT), já podemos combinar seus resultados e criar uma terceira porta lógica: a NAND (ou Not AND).

Ela pode ser representada assim:

Interactive circ widget — view it on the blog.

╭───╮     ╭─────────────╮     ╭───╮
│ a ├○───▶┤             │ ╭──▶┤LED│
╰───╯     │[nand:_nand_]├○╯   ╰───╯
       ╭─▶┤             │          
       │  ╰─────────────╯          
       │                           
╭───╮  │                           
│ b ├○─╯                           
╰───╯                              

Interactive circ widget — view it on the blog.

╭───╮     ╭───╮     ╭───╮     ╭───╮
│ a ├○───▶┤   │ ╭──▶┤NOT├○───▶┤LED│
╰───╯     │AND├○╯   ╰───╯     ╰───╯
       ╭─▶┤   │                    
       │  ╰───╯                    
       │                           
╭───╮  │                           
│ b ├○─╯                           
╰───╯                              

A tabela-verdade dela é idêntica à do AND, porém com os resultados invertidos.

Seguindo essa mesma lógica de combinar portas, podemos usar uma porta NAND e inverter a entrada de cada interruptor com um NOT. Assim, teremos o seguinte:

Interactive circ widget — view it on the blog.

╭───╮     ╭───╮     ╭─────────────╮     ╭───╮
│ a ├○───▶┤NOT├○───▶┤             │ ╭──▶┤LED│
╰───╯     ╰───╯     │[nand:_nand_]├○╯   ╰───╯
                 ╭─▶┤             │          
                 │  ╰─────────────╯          
                 │                           
╭───╮     ╭───╮  │                           
│ b ├○───▶┤NOT├○─╯                           
╰───╯     ╰───╯                              

Analisando o diagrama acima, vemos que, quando os dois interruptores estiverem desligados, ambos os sinais serão invertidos pelo NOT, e o NAND vai resultar em ¬∧(1, 1) = 0. Ou seja, com ambos desligados, a lâmpada apaga. Mas o que acontece quando temos ¬∧(1, 0) ou ¬∧(0, 1)? Para descobrir, vamos analisar a tabela-verdade:

Mas espera um pouco, eu tenho a impressão de que eu já vi essa tabela antes? Sim! Essa é a porta lógica OR que estávamos procurando. Uma viagem e tanto, não é? Agora que já sabemos como consertar a fiação da lâmpada, podemos dar uma paradinha aqui. Este é apenas o primeiro artigo de uma série sobre computadores. Mais para frente, vamos abordar outras portas lógicas e outros conceitos da computação.

Referências

• Álgebra booliana (Wikipédia)
• Boolean Algebra (Wikipédia)
• Tabela-verdade (Wikipédia)
• Exploring How Computers Work (YouTube)
• Making logic gates from transistors (YouTube)
• HOW TRANSISTORS RUN CODE? (YouTube)

Hey Y’all! This is a translation of my blog post originally written in Portuguese.

Revised [11/12/2024]

Hi folks, so I had to make some changes here in the post to add some interactive widgets, and I took the opportunity to give a bit more context to the content.

Hello, this is the first article in a series about the fundamentals of computing. The idea is to demonstrate in a simple and practical way how this device transforms zeros and ones into practically anything, the functioning of CPUs and other interesting subjects. So, to start, the first concept we have to learn is that of logic gates: they are the foundation of all computing, with them we can do certain operations that receive as input one or more values and will have another value as a result.

But what are these values? The number 42? My mother’s name? These “values” are energy, more specifically the presence and absence of it. As mentioned in the introduction, computers work using binary digits, meaning these machines only understand 0 and 1 or “Has energy” and “No energy”. However, we won’t call these zeros and ones energy, for the computer they are signals.

When signals are combined and/or compared, we call it a logical operation, for example.

“[Harp sounds of story beginning]”

One day you hire an electrical company to install two switches in a hallway of your house, but due to a design error, the installation ends up like this: the wire passes through the first switch (let’s call it switch A), goes straight to the second switch (B for intimates) and then exits to the lamp.

Did you notice that the lamp only lights up if both switches are on at the same time? If either one is turned off, the light goes out immediately! Well, this residential electrical atrocity can be explained, in mathematics, from one of its branches called boolean algebra, and in it we can demonstrate this with a table:

Writing this another way looks like this:

If you noticed well, now we have a way to represent what we want to happen with two switches and a lamp, and this example shown above is the first logic gate we’re getting to know, the AND or Conjunction, and this table, demonstrated above in different forms, is called a Truth Table.

Ok, but what about my house light? How is it going to be? I need the light to turn on when A OR B is on. How do you do that?

The answer is in the question itself! 😉 We’ll need another logic gate, the OR or Disjunction, and to understand how it works, let’s use a truth table that fits these conditions:

But before talking about OR, let’s take a look at the NOT gate (or Negation). It’s quite simple, but it will be important later on.

Interactive circ widget — view it on the blog.

╭───╮     ╭───╮     ╭───╮
│ a ├○───▶┤NOT├○───▶┤LED│
╰───╯     ╰───╯     ╰───╯

And if we write it in a truth table we’ll have this here:

So, let’s take a break and review what we already know. First, the operations and how to represent them in a table. To simplify, let’s transform these operations into symbols. Every time we refer to AND, this will be the symbol:

Interactive circ widget — view it on the blog.

╭───╮     ╭───╮     ╭───╮
│ a ├○───▶┤   │ ╭──▶┤LED│
╰───╯     │AND├○╯   ╰───╯
       ╭─▶┤   │          
       │  ╰───╯          
       │                 
╭───╮  │                 
│ b ├○─╯                 
╰───╯                    

and the NOT:

Interactive circ widget — view it on the blog.

╭───╮     ╭───╮     ╭───╮
│ a ├○───▶┤NOT├○───▶┤LED│
╰───╯     ╰───╯     ╰───╯

With these two logical operations (AND and NOT), we can already combine their results and create a third logic gate: the NAND (or Not AND).

It can be represented like this:

Interactive circ widget — view it on the blog.

╭───╮     ╭─────────────╮     ╭───╮
│ a ├○───▶┤             │ ╭──▶┤LED│
╰───╯     │[nand:_nand_]├○╯   ╰───╯
       ╭─▶┤             │          
       │  ╰─────────────╯          
       │                           
╭───╮  │                           
│ b ├○─╯                           
╰───╯                              

Interactive circ widget — view it on the blog.

╭───╮     ╭───╮     ╭───╮     ╭───╮
│ a ├○───▶┤   │ ╭──▶┤NOT├○───▶┤LED│
╰───╯     │AND├○╯   ╰───╯     ╰───╯
       ╭─▶┤   │                    
       │  ╰───╯                    
       │                           
╭───╮  │                           
│ b ├○─╯                           
╰───╯                              

Its truth table is identical to AND’s, but with the results inverted.

Following this same logic of combining gates, we can use a NAND gate and invert each switch input with a NOT. Thus, we’ll have the following:

Interactive circ widget — view it on the blog.

╭───╮     ╭───╮     ╭─────────────╮     ╭───╮
│ a ├○───▶┤NOT├○───▶┤             │ ╭──▶┤LED│
╰───╯     ╰───╯     │[nand:_nand_]├○╯   ╰───╯
                 ╭─▶┤             │          
                 │  ╰─────────────╯          
                 │                           
╭───╮     ╭───╮  │                           
│ b ├○───▶┤NOT├○─╯                           
╰───╯     ╰───╯                              

Analyzing the diagram above, we see that when both switches are off, both signals will be inverted by the NOT, and the NAND will result in ¬∧(1, 1) = 0. So with both off, the lamp turns off. But what happens when we have ¬∧(1, 0) or ¬∧(0, 1)? To find out, let’s analyze the truth table:

But wait a minute, I have the impression that I’ve seen this table before? Yes! This is the OR logic gate we were looking for. Quite a journey, isn’t it? Now that we know how to fix the lamp wiring, we can take a break here. This is just the first article in a series about computers. Later on, we’ll address other logic gates and other computing concepts.

References

• Boolean algebra (Wikipedia)
• Boolean Algebra (Wikipedia)
• Truth table (Wikipedia)
• Exploring How Computers Work (YouTube)
• Making logic gates from transistors (YouTube)
• HOW TRANSISTORS RUN CODE? (YouTube)