DEV Community: Alexandre Pierre

Sibling Relation Transitivity and a Little More

Alexandre Pierre — Fri, 30 May 2025 23:05:38 +0000

I have a small number of friends with whom I discuss any craziness my brain is capable of producing. Some days ago I sent a voice note to one of them (shout out to Iago, I've linked his blog which is way better than mine) saying something along the lines: "I was thinking about transitivity and sibling relations are intransitive if you consider half-siblings as siblings". He replied: "Yes, and it's transitive if you only consider full siblings". Them he went a step ahead and said the same in more mathematical terms, which I explain below:

Intransitive Sibling Relation

\text{Let $S_I$ be the sibling relation as written above, then:} \\ \text{$x ~ S_I ~ y \iff \exists p_{x,y}$ is parents for $x$ and $y$}

I don't think it's necessary to write "parents to" in terms of relations too. But if you, dear reader, disagree you may comment and I'll consider putting it there or to use it to answer the comment itself.

It's possible to prove that the relation is intransitive if we consider that $z$ can be siblings with $y$ but not with $x$ . Even though $x$ and $y$ are siblings to each other.

\text{Let $p_{x,y}$ be the parent to $x$ and $y$} \\ \text{$x ~ S_I ~ y$ because $p_{x,y}$ exists} \\~\\ \text{Let $p_{y,z}$ be the parent to $y$ and $z$} \\ \text{$y ~ S_I ~ z$ because $p_{y,z}$ exists}

But why is this relation intransitive?

Answer: because in the context of half-siblings $x$ and $z$ may not have a common parent.

Transitive Sibling Relation

Exploring mathematically the other observation Iago made:

\text{Let $S_T$ be the full-sibling relation:} \\ \text{$x ~ S_T ~ y \iff \forall p_{x,y}$ are parents for $x$ and $y$}

But how is it different from what we've seen before?

If we are talking about full-siblings, they have to share all parents. And it makes impossible the condition that made $S_I$ intransitive. You can see that in the diagram below, which is minimal for full-sibling relations.

What I've Learned Today: Anti-Transitive Relation

While doing the research for this post I've got acquainted with the concept of Anti-Transitive Relations in the site Geeks for Geeks. Which means a relation $A_T$ that is made impossible between $x$ and $z$ if $x ~ A_T ~ y$ and $y ~ A_T ~ z$ .

Wikipedia article on Transitivity has a very good example that I've used as a base to make my own:

The antitransitive nature of the cycle makes it so Fire beats Leaf, Leaf beats Water but Fire can't beat Water. (If you know enough about pokémon you may know that this model has its limits, but consider only the starter types and not all of pokémon).

Conclusion

To end this text about the examples I really recommend the Geeks for Geeks article, the Wikipedia article on Transitivity and the Wikipedia article on Intransitivity.

Paridade e Representação Binária

Alexandre Pierre — Thu, 22 May 2025 19:03:38 +0000

Primeiramente, por que falar de números pares ou ímpares? A resposta é "porque parece fácil". Quando estamos falando de números em base 10 pode-se olhar para o último dígito e verificar se é par ou não. Com números em base 2 é só verificar se o último dígito é zero (em números pares) ou um (números ímpares).

Determinação de Paridade (até agora)

Sabendo que o computador usa representação binária, podemos usar um operador que faz operações bit a bit de uma linguagem de programação (abaixo faço em Python) para determinar a paridade de um número verificando apenas se o bit menos significativo é zero.

even_number & 1 == 0
> True

odd_number & 1 == 0
> False

Fim do problema?

Sim e não. Se estivermos falando de uma linguagem de programação de alto nível, é provável que o dito acima seja o suficiente para determinar paridade. Também é provável que o compilador ou JIT troque testes de paridade na forma number % 2 == 0 por códigos mais parecidos com os da seção acima.

O problema começa quando estamos mais perto do hardware, lidando com protocolos de transmissão de informação ou simplesmente brincando de fabricar hardware ou testar arquiteturas usando protoboards.

File:400 points breadboard.jpg, https://commons.wikimedia.org/w/index.php?title=File:400_points_breadboard.jpg&oldid=881458324 (last visited May 22, 2025).

A operação acima é facilmente implementável em hardware com apenas uma porta lógica AND.

Representação de números no hardware

Em geral se agrupa os dígitos binários de 8 em 8 para trabalhar com bytes. Saber desse agrupamento é necessário para falar sobre Endianness: big-endian, little-endian e middle-endian.

Endianness

Vou começar dizendo que não vou falar de middle-endian, apesar de interessante, essa explicação não me ajuda muito porque não encontrei nenhum exemplo de uso que combine com a discussão de paridade. Mas a representação middle-endian está bem explicada no link providenciado.

By Aeroid - Own work, CC BY-SA 4.0, https://commons.wikimedia.org/w/index.php?curid=137790829 File:32bit-Endianess.svg, https://commons.wikimedia.org/w/index.php?title=File:32bit-Endianess.svg&oldid=1013043334 (last visited May 22, 2025).

Pensando no "fim" do número como a parte mais à esquerda, é como falamos em endianness.

Big-endian

Big-endian é a representação usual, em que o byte mais significativo é o que está no "fim" como definido acima.

Little-endian

Little-endian é o oposto da representação usual, em que o byte menos significativo é o que está no "fim". Ou seja, a parte menor do número aparece no "fim" (lado esquerdo) em vez de aparecer do lado direito. Um outro problema é que isso é uma inversão de bytes, mas não de bits dentro dos bytes. Vale olhar a imagem abaixo em conjunto com a imagem na seção de Endianness.

Gray Code

Para algumas aplicações que precisam evitar interferências e erros, existe uma outra forma de codificar números em que números seguidos mudam em apenas um bit.

Decimal	Binary	Gray
0	0000	0000
1	0001	0001
2	0010	0011
3	0011	0010
4	0100	0110
5	0101	0111
6	0110	0101
7	0111	0100
8	1000	1100
9	1001	1101
10	1010	1111
11	1011	1110
12	1100	1010
13	1101	1011
14	1110	1001
15	1111	1000

A tabela acima foi copiada da Wikipedia, do artigo sobre Gray Code. Os circuitos que checam o bit menos significativo não são o suficiente para determinar paridade, talvez não seja um circuito difícil de fazer, mas não tão óbvio. Seguindo uma extensa tradição matemática, deixo esse circuito como exercício para o leitor.

Conclusão

Hardware, essa coisa concreta e absolutamente necessária para a computação contemporânea, pode tornar mais difícil fazer operações que podem parecer óbvias. Em geral, temos soluções para isso no meio do ferramental de linguagens de programação e podemos só ler os números da forma que leríamos no papel.

Mas quando se considera toda a teoria e protocolos em todo o caminho desde digitar um número no teclado até acender um bit na memória, as coisas podem se tornar muito mais complexas apesar de o problema em si ser bastante simples. Esse texto não chegou a mencionar representações em Complemento a 2 nem citar arquiteturas específicas que usam uma ou outra representação, também não falei de consequências disso em conjuntos de instruções. Então o universo que cerca esse problema simples e que eu não explorei continua enorme e é super interessante.

leftpad, vibe-coding e o mercado que corta custos a qualquer custo

Alexandre Pierre — Wed, 14 May 2025 23:22:18 +0000

Tenho estado intencionalmente distante da discussão sobre vibe-coding, mas me parece mais uma tentativa de reduzir o conhecimento necessário para desenvolver software sem nenhuma garantia de resultado. Algumas previsões sobre onde isso nos levará me lembraram bastante do desastre que aconteceu no ecossistema de JavaScript, especificamente no npm, em 2016 quando um dev independente entrou em conflito com a própria organização do npm deletou sua conta levando junto um pacote curtinho que ele escreveu.

O pacote se chamava leftpad e seu conteúdo está integralmente na imagem que ilustra esse post, mas vou colocar abaixo também:

module.exports = leftpad

function leftpad (str, len, ch) {
  str = String(str);

  var i = -1;

  ch || (ch = ' ');
  len = len - str.length;


  while (++i < len) {
    str = ch + str;
  }

  return str;
}

O problema é que esse pacote era dependência direta ou indireta de muitos outros pacotes. Muitos projetos que estavam no ar quebraram, alguns por minutos outros por horas, por falta desse pacote. Para ler mais sobre o incidente, recomendo a página da Wikipedia sobre o ocorrido.

Muita gente apontava que um ecossistema baseado em usar pacotes de terceiros para as tarefas mais simples e curtas, e manter tudo sendo atualizado automaticamente era problemático. Não imaginávamos necessariamente um leftpad, estávamos mais preocupados com algo na linha de rand-user-agent. No fim, ambos ocorreram.

Não é só um problema do mercado

Muitos de nós temos programação como hobby além de trabalho e em nossos projetos paralelos podemos acabar usando ferramentas que façam parte das tarefas para nós. Às vezes disponibilizamos nossos projetos de forma open-source, às vezes não. Às vezes o projeto ganha corpo, passa a ser usado e um erro seu vira problema de todo mundo ou um erro de alguém que você nunca viu vira problema seu.

Um exemplo de como a tirinha acima se aplica ao mundo real e de como um erro seu num projeto que ninguém te paga para fazer vira problema de todo mundo é o ocorrido com o Log4j.

Por que o Log4j não está no título

O Log4j não se encaixa exatamente na crítica do texto, ele só aparece pra nos lembrar que correr para usar algo pronto não é só problema do patrão e que se correrem para usar algo nosso é melhor termos uma licença que garanta que não nos responsabilizaremos pelos danos ou que deveriam estar nos pagando para resolver os problemas decorrentes.

A mão invisível quebra os próprios dedos

A crítica aqui é bem simples, se o mercado busca maximizar o lucro imediato a cada passo de cada processo, na produção de software haverá a tendência a tomar decisões como:

baratear força de trabalho
encurtar prazos
cortar caminhos

Contratando gente menos capacitada e/ou menos gente, leftpad (software modular com cada pedacinho já pronto) permitia que as pessoas entrassem no mercado com quase nenhum conhecimento além de npm install ...

Vibe coding está provocando um processo parecido e produzindo software cheio de defeitos e falhas de segurança. Minha previsão pessoal era que as equipes encolheriam e sobraria um sênior usando IA e resolvendo os problemas, talvez eu tenha errado nessa.

O dito acima já cobre a parte de cortar caminhos, o encurtamento de prazos só garante que ninguém vai conseguir perceber os problemas criados a não ser que haja incentivo externo, como na área bancária que é fortemente regulada.

Conclusão

Pro dev: "busque conhecimento" - ET Bilu.

Pra empresa: faça uma análise mínima de risco e tome o cuidado de não economizar um real agora pra quebrar no futuro sem conseguir resolver os problemas que criou hoje. Tenha bons devs e contrate QAs.

Comutativa Não-Associativa e Associativa Não-Comutativa

Alexandre Pierre — Sat, 10 May 2025 17:00:31 +0000

Em uma das vezes que decidi estudar Teoria das Categorias, parcialmente por causa de Programação Funcional, Provadores Automáticos e parcialmente por nenhum motivo em especial. Essa foi provavelmente a vez que levei o assunto mais a sério e tentei criar intuição sobre vários tópicos que encontrei no caminho.

Até hoje não posso dizer que entendo bem Teoria das Categorias, mas consegui alguns exemplos e intuições úteis no caminho. Nesse texto vou falar sobre quando precisei entender Comutatividade e Associatividade como propriedades separadas, afinal é muito fácil pensar nas duas juntas já que os conjuntos de números que usamos no dia-a-dia tem ambas as propriedades. A seguir vou mostrar os exemplos e explica-los em algum nível. Podem botar dúvidas nos comentários ou outros exemplos, a discussão é bem-vinda.

Operação comutativa, mas não-associativa

Vou usar uma notação levemente diferente, mas gosto de usar operadores infixos para esse assunto, então prefiro descrever a operação abaixo da mesma forma. Vou usar a média de dois números racionais ( $Q\mathbb{Q}$ ).

\star q \triangleq \frac{p + q}{2}

Média é uma operação comutativa

\star q = \frac{p + q}{2} = \frac{q + p}{2} = q \star p

Mas média não é associativa

\star q) \star r = \frac{\frac{p + q}{2} + r}{2} = \frac{\frac{p}{2} + \frac{q}{2} + r}{2} = \frac{p}{4} + \frac{q}{4} + \frac{r}{2} \\~\\ p \star (q \star r) = \frac{p + \frac{q + r}{2}}{2} = \frac{p + \frac{q}{2} + \frac{r}{2}}{2} = \frac{p}{2} + \frac{q}{4} + \frac{r}{4} \\~\\ \frac{p}{4} + \frac{q}{4} + \frac{r}{2} \neq \frac{p}{2} + \frac{q}{4} + \frac{r}{4} \to (p \star q) \star r \neq p \star (q \star r) \\~\\

Dando um exemplo com números.

\qquad q = 2; \qquad r = 3 \\~\\ (p \star q) \star r = (1 \star 2) \star 3 = \frac{\frac{1 + 2}{2} + 3}{2} = \frac{\frac{3}{2} + 3}{2} = \frac{3}{4} + \frac{3}{2} = \frac{3}{4} + \frac{6}{4} = \frac{9}{4} \\~\\ p \star (q \star r) = 1 \star (2 \star 3) = \frac{1 + \frac{2 + 3}{2}}{2} = \frac{1 + \frac{5}{2}}{2} = \frac{1}{2} + \frac{5}{4} = \frac{2}{4} + \frac{5}{4} = \frac{7}{4} \\~\\ \frac{9}{4} \neq \frac{7}{4}

Operação associativa, mas não comutativa

O concatenação de strings (encadeamento de sequências de símbolos) é um exemplo de operação que é associativa, mas não é comutativa. Para diferenciar um símbolo que seja uma variável de um que seja o valor de uma vou usar aspas duplas para os valores.

\text{ é uma variável} \\~\\ "x" \text{ é um valor}

Primeiro um símbolo infixo para concatenação, vou usar o mesmo da linguagem de programação Julia.

"\text{a}" * "\text{b}" \triangleq "\text{ab}"

Concatenação de strings não é comutativa

Parece óbvio, mas vou dar só um contraexemplo.

"\text{a}" * "\text{b}" = "\text{ab}" \\~\\ "\text{b}" * "\text{a}" = "\text{ba}" \\~\\ "\text{ab}" \neq "\text{ba}" \to "\text{a}" * "\text{b}" \neq "\text{b}" * "\text{a}"

Concatenação de strings é associativa

Dadas 3 strings $\text{ e } z$ quaisquer, vale o abaixo.

x * y * z = x * (y * z) = (x * y) * z

Para um exemplo com valores:

"\text{obrigado}" \\~\\ y = "\text{ por ler}" \qquad \text{(observe o espaço no início)} \\~\\ z = "\text{ até aqui}" \qquad \text{(observe o espaço no início)} \\~\\ x * (y * z) = "\text{obrigado}" * ("\text{ por ler}" * "\text{ até aqui}") = "\text{obrigado}" * "\text{ por ler até aqui}" = "\text{obrigado por ler até aqui}" \\~\\ (x * y) * z = ("\text{obrigado}" * "\text{ por ler}") * "\text{ até aqui}") = "\text{obrigado por ler}" * "\text{ até aqui}" = "\text{obrigado por ler até aqui}" \\~\\ x * (y * z) = (x * y) * z = x * y * z = "\text{obrigado por ler até aqui}"

Muito obrigado por ler até aqui. Esses exemplos junto com o produto de matrizes (que também é associativo, mas não comutativo) me ajudaram muito numa das vezes que tentei estudar Teoria das Categorias. Espero que seja útil para mais alguém.