<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" xml:lang="pt-BR"><generator uri="https://jekyllrb.com/" version="3.10.0">Jekyll</generator><link href="https://eduardo-pr-alves.github.io/feed.xml" rel="self" type="application/atom+xml" /><link href="https://eduardo-pr-alves.github.io/" rel="alternate" type="text/html" hreflang="pt-BR" /><updated>2026-09-23T21:37:38+00:00</updated><id>https://eduardo-pr-alves.github.io/feed.xml</id><title type="html">Eduardo Pereira Ribeiro Alves</title><subtitle>Programador backend Java com alguns anos de experiência em desenvolvimento, querendo sempre aprender mais e compartilhar meus aprendizados e desafios com o mundo. Aqui você vai ver um pouco de tudo: desenvolvimento, carreira, vida pessoal… enfim, fique à vontade para me mandar uma mensagem e trocar figurinhas!</subtitle><author><name>Eduardo Pereira Ribeiro Alves</name></author><entry><title type="html">Escovando bits: criando nossa primeira máquinas de somar</title><link href="https://eduardo-pr-alves.github.io/2026/09/23/escovando-bits-criando-nossa-primeira-maquinas-de-somar/" rel="alternate" type="text/html" title="Escovando bits: criando nossa primeira máquinas de somar" /><published>2026-09-23T19:59:15+00:00</published><updated>2026-09-23T19:59:15+00:00</updated><id>https://eduardo-pr-alves.github.io/2026/09/23/escovando-bits-criando-nossa-primeira-maquinas-de-somar</id><content type="html" xml:base="https://eduardo-pr-alves.github.io/2026/09/23/escovando-bits-criando-nossa-primeira-maquinas-de-somar/"><![CDATA[<h2 id="introdução">Introdução</h2>
<p>Como vimos no post anterior podemos, com algumas operações simples, fazermos vários testes lógicos com zeros e uns. Operações booleanas. Se você não viu o teste anterior, <a href="http://http://epribeiro.com.br/2026/09/23/escovando-bits-binario-e-operadores-logicos/">pode seguir por aqui</a>.</p>

<p>Agora, com aqueles conceitos já bem definidos, vamos pensar um pouco sobre como podemos efetivamente fazer contas com aquilo. Pequenas máquinas de somar.</p>

<h2 id="computadores-são-máquinas-de-somar">Computadores são máquinas de somar</h2>
<p>No post anterior, falamos que todas as operações que um computador faz, das mais simples até as mais complicadas, são somas disfarçadas.</p>

<p>Falamos também que o computador só entende o que é 0 e 1. Mas como ele pode somar dois números, por exemplo, 2 + 3, e nos dar o resultado 5, sendo que ele nem sabe o que é um “2”, nem um “3”? Muito menos um “5”.</p>

<p>Bom, dentro dos computadores, temos uma peça central chamada CPU (Unidade de Processamento Central, em português) que é responsável por interpretar os comandos dos programas e executar o que quer que eles façam. Se dermos um zoom muito agressivo nessa peça, chegaremos em dois componentes que fazem toda a mágica acontecer: o <em>half-adder</em> e o <em>full-adder</em>.</p>

<h3 id="como-o-computador-junta-dois-números">Como o computador junta dois números?</h3>
<p>Na eletrônica, ciência base da programação, os componentes centrais que fazem tudo acontecer são chamados de <strong>transistores</strong>. Eles são pequenos interruptores elétricos que, quando são submetidos a uma determinada voltagem, deixam uma corrente passar. Um transistor tem dois estados: ligado, onde ele deixa a corrente passar; e desligado, onde ele não deixa. Daí que vem o 0 e 1 da programação. Nada mais é do que uma representação abstrata do “ligado” e “desligado” do transistor.</p>

<p>Podemos representar qualquer número com esse sistema de ligado e desligado. Por exemplo: o número 3, nesse sistema, pode ser representado por <code class="language-plaintext highlighter-rouge">0011</code>. A mesma coisa com o número 2, que ficaria <code class="language-plaintext highlighter-rouge">0010</code>. O 5, por sua vez, é <code class="language-plaintext highlighter-rouge">0101</code>.</p>

<p>Assim como na matemática tradicional, quando um número é maior que 9, na unidade, adicionamos um na dezena e recomeçamos a conta (exemplo: …7, 8, 9, <strong>1</strong>0, <strong>1</strong>1…), nos números binários acontece a mesma coisa. Só que como estamos trabalhando com apenas dois dígitos, assim que o valor chega em 1, eu passo para a próxima casa. Exemplo:</p>

<table>
  <thead>
    <tr>
      <th>Milhar</th>
      <th>Centena</th>
      <th>Dezena</th>
      <th>Unidade</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>0</td>
    </tr>
    <tr>
      <td>0</td>
      <td>0</td>
      <td>0</td>
      <td>1</td>
    </tr>
    <tr>
      <td>0</td>
      <td>0</td>
      <td>1</td>
      <td>0</td>
    </tr>
    <tr>
      <td>0</td>
      <td>0</td>
      <td>1</td>
      <td>1</td>
    </tr>
  </tbody>
</table>

<p>Assim, sucessivamente.</p>

<p>Para somar dois números na matemática decimal, é simples: Eu complemento o valor de um com o valor de outro e tenho o resultado final. Dois mais dois é quatro porque se eu pego duas unidades de alguma coisa e junto com duas outras unidades dessa mesma coisa, dá quatro unidades. Vamos tentar abstrair, imaginar, esse conceito para a matemática dos binários.</p>

<p>Comecemos simples, 1+1 = 2. Nada muito complexo para não cansar:</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>    1
  0001
+ 0001
______
  0010
</code></pre></div></div>
<p>Perceba o seguinte: quando queremos somar “1” com “1” em binário, não podemos colocar o resultado “2”, porque isso ultrapassaria o limite do sistema. Imagine que você quer somar 25+25. Você</p>
<ul>
  <li>soma 5+5 primeiro, que dá 10;</li>
  <li>passa a dezena do dez para a próxima casa, o famoso “vai um”;</li>
  <li>soma 2+2, que dá 4. Mais 1, do “vai um” que subiu;</li>
  <li>no final, chegamos no resultado “50”, que é o valor certo.</li>
</ul>

<p>Em binário, estamos fazendo a mesma coisa:</p>
<ul>
  <li>soma <code class="language-plaintext highlighter-rouge">0001</code>+<code class="language-plaintext highlighter-rouge">0001</code> primeiro, que dá <code class="language-plaintext highlighter-rouge">0010</code> (lembre-se, estamos somando primeiro as unidades);</li>
  <li>passa o 1 da dezena para a próxima casa, o famoso “vai um”;</li>
  <li>soma 0+0, que dá 0. Mais 1, do “vai um” que subiu;</li>
  <li>no final, chegamos no resultado <code class="language-plaintext highlighter-rouge">0010</code>, que é o valor certo.</li>
</ul>

<p>Em inglês, o “vai um” é chamado de <em>carry</em> e é padrão de nomenclatura que vocês acharão por aí. Por isso, de agora em diante, o chamaremos assim.</p>

<h3 id="descobrindo-um-padrão-interessante">Descobrindo um padrão interessante</h3>
<p>Olha só, se pararmos para pensar, dá até para achar um padrão nessas somas de binários. Não é como se precisássemos achar todos os padrões entre 0 e 9. É só entre 0 e 1. Vamos tentar montar uma tabelinha para descobrir essas somas:</p>

<table>
  <thead>
    <tr>
      <th>A</th>
      <th>B</th>
      <th>Resultado</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>0</td>
      <td>0</td>
      <td>0</td>
    </tr>
    <tr>
      <td>0</td>
      <td>1</td>
      <td>1</td>
    </tr>
    <tr>
      <td>1</td>
      <td>0</td>
      <td>1</td>
    </tr>
    <tr>
      <td>1</td>
      <td>1</td>
      <td>0 (já vamos falar desse caso)</td>
    </tr>
  </tbody>
</table>

<p>Se você for atento ao post anterior, você vai descobrir de onde é que essa tabelinha existe: <strong>A CONDIÇÃO XOR</strong>! Quando estamos somando dois números binários no computador, estamos apenas aplicando a condição do OU eXclusivo, o XOR. Se a gente conseguisse fazer um dispositivo, usando transistores, que simulasse esse comportamento do XOR, dava pra somar dois números binários! Para nossa sorte, existe, e já vamos montar ele já, já. Antes disso vamos dar uma olhada naquele caso ali.</p>

<p>Perceba que se eu somar <code class="language-plaintext highlighter-rouge">0001</code>+<code class="language-plaintext highlighter-rouge">0001</code>, eu vou ter um “vai um”. Isso é o que chamamos de <em>carry</em>. Ele é um tópico interessante e apartado porque dá pra calcular ele utilizando outra tabelinha.</p>

<table>
  <thead>
    <tr>
      <th>A</th>
      <th>B</th>
      <th>Carry</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>0</td>
      <td>0</td>
      <td>0</td>
    </tr>
    <tr>
      <td>0</td>
      <td>1</td>
      <td>0</td>
    </tr>
    <tr>
      <td>1</td>
      <td>0</td>
      <td>0</td>
    </tr>
    <tr>
      <td>1</td>
      <td>1</td>
      <td>1</td>
    </tr>
  </tbody>
</table>

<p>Novamente, podemos notar certa semelhança entre essa tabela e a do post anterior. Ela é, nada mais, nada menos, do que uma <strong>CONDIÇÃO “E”</strong>. Perceba, eu só vou ter <em>carry</em> quando os dois valores forem verdadeiros, 1.</p>

<p>Bom, com isso, acho que já dá para juntar os dois conceitos.</p>

<h3 id="transformando-conceitos-em-realidade">Transformando conceitos em realidade</h3>
<p>Se existisse uma maneira de transformar esses operadores “XOR” e “E” em coisas físicas, reais, peças de eletrônica, daria para ver na prática essas tabelas funcionando.</p>

<p>Então, existe. Vamos usar aqui o site <a href="https://logic.ly/">Logic.ly</a> como demonstração.</p>

<p>Vamos começar: vou adicionar dois interruptores que vão fazer aqui o papel de transistor. Eles vão ser o nosso 1 e 0. E vou conectá-los a uma condicional lógica, a condicional “XOR”.</p>

<p><img src="/assets/images/2026-09-23-escovando-bits-criando-nossa-primeira-maquinas-de-somar/porta-xor.png" alt="" /></p>

<p>Cada uma das condicionais ou portas tem um símbolo específico. Esse é a do “XOR”. Ao longo do post, vamos descobrindo um por um. O que devemos nos atentar agora é se ela corresponde ao que vimos na tabela.</p>

<p><img src="/assets/images/2026-09-23-escovando-bits-criando-nossa-primeira-maquinas-de-somar/porta-xor-1-0.png" alt="" /></p>

<p><img src="/assets/images/2026-09-23-escovando-bits-criando-nossa-primeira-maquinas-de-somar/porta-xor-0-1.png" alt="" /></p>

<p><img src="/assets/images/2026-09-23-escovando-bits-criando-nossa-primeira-maquinas-de-somar/porta-xor-1-1.png" alt="" /></p>

<p>Como podemos ver, realmente, ela segue todos os conceitos da tabela que montamos, ou seja, estamos no caminho certo.</p>

<p>Entretanto, isso não seria o suficiente para montar nossa máquina de somar 1 com 1 em binário. Na última imagem acima, podemos perceber que, se eu adicionar um mais um, a lâmpada não acende. Como vamos tratar o <em>carry</em>?</p>

<p>Ora, muito simples. Se já sabemos que a tabela para calcular o <em>carry</em> é a tabela da condicional “E”, é só adicioná-la ao diagrama.</p>

<p><img src="/assets/images/2026-09-23-escovando-bits-criando-nossa-primeira-maquinas-de-somar/ha-0-0.png" alt="" /></p>

<p><img src="/assets/images/2026-09-23-escovando-bits-criando-nossa-primeira-maquinas-de-somar/ha-1-0.png" alt="" /></p>

<p><img src="/assets/images/2026-09-23-escovando-bits-criando-nossa-primeira-maquinas-de-somar/ha-0-1.png" alt="" /></p>

<p><img src="/assets/images/2026-09-23-escovando-bits-criando-nossa-primeira-maquinas-de-somar/ha-1-1.png" alt="" /></p>

<p>Pronto, adicionando a condicional “E”, já podemos calcular o valor do <em>carry</em> também. Isso é o que chamamos de <em>half-adder</em>. Ele já consegue calcular parte do que precisamos, mas ainda tem alguns pontos para melhorar e transformar isso num <em>full-adder</em> e, aí sim, somar 1+1.</p>

<p>Por enquanto, é só isso. Amanhã voltamos com mais para continuar a nossa série!</p>]]></content><author><name>Eduardo Pereira Ribeiro Alves</name></author><category term="tecnologia" /><category term="programação" /><category term="tech" /><category term="programação" /><category term="eletrônica" /><category term="lógica" /><summary type="html"><![CDATA[Introdução Como vimos no post anterior podemos, com algumas operações simples, fazermos vários testes lógicos com zeros e uns. Operações booleanas. Se você não viu o teste anterior, pode seguir por aqui.]]></summary></entry><entry><title type="html">Escovando bits: binário e operadores lógicos</title><link href="https://eduardo-pr-alves.github.io/2026/09/23/escovando-bits-binario-e-operadores-logicos/" rel="alternate" type="text/html" title="Escovando bits: binário e operadores lógicos" /><published>2026-09-23T15:43:04+00:00</published><updated>2026-09-23T15:43:04+00:00</updated><id>https://eduardo-pr-alves.github.io/2026/09/23/escovando-bits-binario-e-operadores-logicos</id><content type="html" xml:base="https://eduardo-pr-alves.github.io/2026/09/23/escovando-bits-binario-e-operadores-logicos/"><![CDATA[<h2 id="introdução">Introdução</h2>
<p>Uma das coisas mais incríveis que eu acho da computação é justamente a simplicidade que algumas operações complexas escondem.</p>

<p>Tudo que existe relacionado a computadores hoje em dia, são nada mais nada menos, que somas. Pense em qualquer coisa que você possa pensar que um computador pode fazer. Desde transações bancárias, até a curtida numa rede social, até a postagem nesse blog. Tudo isso é feito apenas com somas. Obviamente, uma grande quantidade delas, mas ainda sim, somas simples entre dois números.</p>

<p>Pensar nisso não parece tão absurdo quando lembramos que computadores são, na realidade, calculadoras muito avançandas, que conseguem realizar diversos cálculos mediante instruções previamente estabelecidas. Uma calculadora simples, não pode, por exemplo, executar programas. Um computador sim. Essa é a diferença crucial entre um e outro. Existem mais alguma coisas, mas não vou me ater nisso agora.</p>

<h2 id="matemática-booleana">Matemática booleana</h2>
<p>Que todas essas operações são resultados diretos de somas, nós já entendemos. Mas, que tipo de soma estamos falando? Bom, um computador, diferente de um ser humano, só aceita dois tipos de números como valores válidos: 0 e 1. É o famoso código binário. Ele, o computador, não sabe me dizer o que é um número 5, por exemplo, mas ele sabe muito bem o que é <code class="language-plaintext highlighter-rouge">0101</code>. Inclusive, você saberia me dizer? Qual a diferença entre o número 101 e <code class="language-plaintext highlighter-rouge">101</code> (binário)? É o que na matemática chamamos de <strong>base</strong>. Um está na base decimal (ou base dez), que é contada de 0 até 9. O outro está na base binária, que é contada com 0 e 1. Para simplificar o entendimento e deixar todo mundo na mesma linha, quando eu estiver falando de binário, vou colocar o texto numa formatação diferente. Vai ficar mais fácil.</p>

<h2 id="operadores-lógicos">Operadores lógicos</h2>
<p>Ok, já entendemos com o que um computador pensa: números binários. Mas como podemos fazer contas com isso? Na realidade, o processo é bem simples. Assim como na matemática “convencional” nós temos as operações de adição, subtração, multiplicação, divisão etc., no matemática binária (chamada formalmente de lógica booleana) nós temos as operações:</p>
<ul>
  <li>E;</li>
  <li>OU;</li>
  <li>OU EXCLUSIVO (XOR);</li>
  <li>NÃO.</li>
</ul>

<p>Existem outras, mas vamos focar nessas por enquanto.</p>

<h3 id="operador-e">Operador “E”</h3>
<p>Imagine que você precisa me dizer duas condições e elas precisam ser verdadeiras para alguma outra coisa acontecer. Exemplo: <em>se eu estiver com fome</em> <strong>E</strong> <em>tiver dinheiro na conta</em>, então <em>peço um iFood</em>. Nesse exemplo, para eu pedir um iFood, eu tenho que ter duas condições verdadeiras (estar com fome e tiver dinheiro na conta). Assim funciona o operador E. Eu preciso que duas coisas sejam verdade para que a terceira também seja verdade. Considerando que 0 é falso e 1 é verdadeiro, podemos montar a seguinte tabela:</p>

<table>
  <thead>
    <tr>
      <th>1ª condição</th>
      <th>2ª condição</th>
      <th>Resultado</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>0</td>
      <td>0</td>
      <td>0</td>
    </tr>
    <tr>
      <td>0</td>
      <td>1</td>
      <td>0</td>
    </tr>
    <tr>
      <td>1</td>
      <td>0</td>
      <td>0</td>
    </tr>
    <tr>
      <td>1</td>
      <td>1</td>
      <td>1</td>
    </tr>
  </tbody>
</table>

<p>Perceba que o resultado só é 1 quando as duas condições forem 1 também.</p>

<h3 id="operador-ou">Operador “OU”</h3>
<p>Ao contrário do operador “E”, o operador “OU” funciona caso uma das condições seja verdade. Ela não precisa que as duas sejam verdade, apenas uma basta. Exemplo:  <em>Se eu tiver um gato</em> <strong>OU</strong> <em>tiver um cachorro</em>, então <em>vou dar muito carinho</em>. Perceba que não importa qual das duas condições são verdadeiras, independentemente se for um gato ou um  cachorro, eu vou dar muito carinho. Só não vou dar carinho se eu não tiver nem gato, nem cachorro. Montando a tabela semelhante, temos:</p>

<table>
  <thead>
    <tr>
      <th>1ª condição</th>
      <th>2ª condição</th>
      <th>Resultado</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>0</td>
      <td>0</td>
      <td>0</td>
    </tr>
    <tr>
      <td>0</td>
      <td>1</td>
      <td>1</td>
    </tr>
    <tr>
      <td>1</td>
      <td>0</td>
      <td>1</td>
    </tr>
    <tr>
      <td>1</td>
      <td>1</td>
      <td>1</td>
    </tr>
  </tbody>
</table>

<p>Novamente, podemos constatar que, nas seguintes condições, tendo apenas uma condição verdadeira, então o resultado será verdadeiro.</p>

<h3 id="operador-ou-exclusivo-xor">Operador “OU eXclusivo, XOR”</h3>
<p>Aqui entramos num campo um pouco mais difícil de exemplificar no mundo real, mas juro que tentarei dar o meu melhor. Muito semelhante ao já visto “OU”, o “XOR” (conotação inglesa para <em>eXclusive OR</em>, ou “OU Exclusivo” em pt-BR), ele funciona da seguinte maneira: o resultado só será verdadeiro se as condições forem, <strong>estritamente</strong>, diferentes. Exemplo: Você foi num restaurante e o atendente falou que o combo que você pediu tem direito a uma sobremesa. Você pode escolher <strong>exclusivamente</strong> entre o sorvete ou a tortinha. Não dá para não escolher e você também não pode escolher os dois. Ou um é verdadeiro e o outro é falso, ou um é falto e o outro é verdadeiro. Se os dois forem falsos ou verdadeiros, então o resultado é falso. Vamos para a tabela:</p>

<table>
  <thead>
    <tr>
      <th>1ª condição</th>
      <th>2ª condição</th>
      <th>Resultado</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>0</td>
      <td>0</td>
      <td>0</td>
    </tr>
    <tr>
      <td>0</td>
      <td>1</td>
      <td>1</td>
    </tr>
    <tr>
      <td>1</td>
      <td>0</td>
      <td>1</td>
    </tr>
    <tr>
      <td>1</td>
      <td>1</td>
      <td>0</td>
    </tr>
  </tbody>
</table>

<p>Perceba que, ao contrário do “OU” normal, até quando os dois são verdadeiros, o resultado é falso.</p>

<h3 id="operador-não">Operador “NÃO”</h3>
<p>Esse é o mais simples de todos. Basicamente, o que é verdadeiro vira falso e o que é falso, verdadeiro. Exemplo: Eu tenho um carro. Após aplicar o operador “NÃO”: Eu não tenho um carro. Na tabela:</p>

<table>
  <thead>
    <tr>
      <th>1ª condição</th>
      <th>Resultado</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>0</td>
      <td>1</td>
    </tr>
    <tr>
      <td>1</td>
      <td>0</td>
    </tr>
  </tbody>
</table>

<p>Esse não precisa de tantas condições porque é literalmente só inverter a condição.</p>

<h2 id="conclusão">Conclusão</h2>
<p>Nesse post vimos, de maneira bem resumida, como computadores “pensam”, como eles o fazem e como podemos brincar com os zeros e uns  para montar pensamentos lógicos de decisão. Nos próximos tópicos, vamos conversar um pouco mais de como aplicar esses operadores para montar pequenas máquinas de somar (<em>half-adder</em>) e, em seguida uma máquina de somar completa (<em>full-adder</em>).</p>]]></content><author><name>Eduardo Pereira Ribeiro Alves</name></author><category term="tecnologia" /><category term="programação" /><category term="bits" /><category term="computadores" /><category term="eletrônica" /><category term="operadores" /><category term="lógica" /><summary type="html"><![CDATA[Introdução Uma das coisas mais incríveis que eu acho da computação é justamente a simplicidade que algumas operações complexas escondem.]]></summary></entry><entry><title type="html">O que as redes sociais se tornaram?</title><link href="https://eduardo-pr-alves.github.io/2026/09/23/o-que-as-redes-sociais-se-tornaram/" rel="alternate" type="text/html" title="O que as redes sociais se tornaram?" /><published>2026-09-23T00:00:00+00:00</published><updated>2026-09-23T00:00:00+00:00</updated><id>https://eduardo-pr-alves.github.io/2026/09/23/o-que-as-redes-sociais-se-tornaram</id><content type="html" xml:base="https://eduardo-pr-alves.github.io/2026/09/23/o-que-as-redes-sociais-se-tornaram/"><![CDATA[<p>Ok, eu sei que eu não sou a pessoa mais antiga da internet. Antes de eu sequer existir nesse plano, já existiam tecnologias de interações sociais na rede que conectavam pessoas do mundo todo. ICQ, os BBS (Bulletin Board System), toda a rede de e-mail já estavam online em ’99.</p>

<p>Person using vintage computer displaying a bulletin board system menu
Representação de um BBS (imagem gerada por IA)
Entretanto eu não posso negar que quando eu me entendi por gente nesse mundo virtual, as redes sociais me acompanharam desde o início. Lembro-me de pedir para minha irmã criar um site para mim e, quando não poderia fazê-lo tamanha a complexidade (grana), ela decediu me convencer que o Orkut era como se fosse um “site” para todo mundo. E, de fato, era. Uma página pessoal, a possibilidade de conectar com outras pessoas, joguinhos, comunidades… Era tudo que um site poderia fazer, e mais. Entenda site, nesse contexto, como um blog ou algo do gênero.</p>

<p>Quando entrei no Orkut, tudo era ainda muito arcaico. Não existiam algoritmos de recomendação e as postagens que apareciam eram simplesmente das pessoas que você adicionava como amigo. Se você não tivesse amigo nenhum, que era mais ou menos o meu caso, a “timeline” (vou usar esse termo porque não me lembro ao certo qual era o termo que eles usavam) ficava vazia. Triste, triste. Isso meio que te incentivava também a ir procurar outras pessoas, adicionar amigos, amigos de amigos, criar uma, adivinhem só, rede social.</p>

<p>Assim era a experiência de usar o Orkut
Não vou me ater aos joguinhos e as sistemas de pontuação que existiam por lá senão ficamos aqui o dia todinho, mas era um lugar divertido de se ficar. Lembro-me também que as minhas inscrições nas comunidades eram sempre lotadas, sempre querendo fazer parte de todos os grupos ao mesmo tempo.</p>

<p>Mas aí então, veio 2010. Não sei se nessa época o Facebook já tinha estreado no Brasil e eu só estava atrasado, mas eu sei que foi nessa época que eu entrei por lá. Era tudo quadrado, sem graça, azul. Não dava para mudar o fundo, as cores, os temas. Você tinha que refazer todo o seu círculo social. Não tinha como importar os amigos e as comunidades para ele. Terrível. Ficava me perguntando: “por que eles lançaram isso aqui no Brasil quando a gente já tem o Orkut? É bem mais legal”. Ledo engano. Em 2014, o Orkut já parecia mais um cemitério e lá se foi a rede social que eu mais gostava.</p>

<p>Avançando no tempo e tendo evoluído os meios de comunicação, chegamos finalmente no que temos hoje: Instagram, X, Facebook, Youtube e outras. Há quem coloque nesse bolo o WhatsApp, o que eu acho um equívoco, dado na natureza do serviço. Se desse para entrar no perfil e adicionar os contatos dos meus contatos, aí sim teríamos uma rede social. Do contrário é só um mensageiro mesmo. Mas, sei lá, mesmo com tanto tempo e tanta evolução, eu fico pensando na simplicidade do que era o Orkut, hoje em dia.</p>

<p>No Facebook, hoje, não podemos curtir um vídeo diferente que a nossa timeline só se torna aquilo. Gosto de escutar alguns recitadores do Alcorão de vez em quando. Se eu curtir um vídeo sobre o Islã, pronto, o algoritmo já acha que eu sou o próximo profeta da religião. Se eu curto uma ou duas pregrações, pronto, sou o próximo papa. Não existe uma margem para respiro.</p>

<p>E isso não é exclusividade do Facebook, não. O Youtube funciona na mesma linha. O X é um caso a parte, porque ele também implementa essas questões de análise, mas ele é tóxico por natureza, por design. Ele faz você sentir raiva para comentar, para brigar, criar mais conteúdo (e não vamos nos esquecer o motivo pela qual ele quer isso: alimentar IA). Essa é a linha do X. Agora, com o domínio do Elon Musk, parece que isso se intensificou. O que quero dizer é: cadê aquela vontade de se conectar, criar amizades, conversar com as pessoas? Não existe mais. Não é para existir mais.</p>

<p>O mundo, hoje em dia, virou apenas uma grande fonte de consumo. Nada é feito para as conexões modernas. O que me gera o seguinte sentimento/dúvida: as redes sociais, hoje em dia, ainda são redes sociais? Óbvio que, pela finalidade dos seus serviços principais, elas se encaixam nessa categoria, mas será que elas não estão evoluindo para algo maior, ou pior?</p>

<p>Não há mais o que descobrir. Não há mais quem conhecer. Agora é tudo conteúdo. Redes sociais voltadas ao conteúdo. Projetadas e analisadas para manter você no caminho que você já está. Não há críticas. Não há novidade. Só aquilo que eles, e você, sabe que vai consumir. Os mesmos vídeos, as mesmas dancinhas, os mesmos políticos para você endeusar ou meter bronca.</p>

<p>Talves por isso também eu tive a vontade de criar esse blog. Ter o meu canto, ter os meus pensamentos, sem ser influenciado, seja pelo algoritmo, seja pelo criador de conteúdo. Recomendo que você faça o mesmo.</p>]]></content><author><name>Eduardo Pereira Ribeiro Alves</name></author><category term="tecnologia" /><category term="geral" /><category term="pensamentos" /><summary type="html"><![CDATA[Ok, eu sei que eu não sou a pessoa mais antiga da internet. Antes de eu sequer existir nesse plano, já existiam tecnologias de interações sociais na rede que conectavam pessoas do mundo todo. ICQ, os BBS (Bulletin Board System), toda a rede de e-mail já estavam online em ’99.]]></summary></entry></feed>