Willian Albarello @wepiphany@qoto.org

Acordei 00... sendo que tenho q fazer uma ressonância da cabeça e dps aula... tô zoado

União soviética invade 198* e uns quebrados o Afeganistão, os radicais(refugiados) fogem para o Iran. Dinastania de Palav cai naquele mesmo ano, os khamene ascendem, o país passa a ser shiita.. Afeganistão sob o Talibã é um chiqueiro ainda pior que o Iran.. Mas sim, meu professor esquerdista é quem está com a razão...
"- Império de Satã..
- Quem?
- Estados Unidos, porra."

E pior, me estresso a pressão do crânio entre em pré-aneurisma/avc agr o corpo se acostumou pular direto pra 245/135 de pressão... Avisei uns colegas legais, to bem mas não é garantia, posso cair morto a qlq momento q D'us me livre.

## 🧱 Granularidade

Funções pequenas (bom) vs função gigante (ruim)

```python
# ruim (tudo junto)
def processar_usuario(usuario):
print(usuario["nome"])
if usuario["idade"] > 18:
print("adulto")

# bom (granular)
def mostrar_nome(usuario):
print(usuario["nome"])

def eh_adulto(usuario):
return usuario["idade"] > 18
```

---

## 🧩 Modularidade

Separar em arquivos

```python
# arquivo: usuario.py
def criar(nome):
return {"nome": nome}

# arquivo: main.py
from usuario import criar

u = criar("Will")
```

---

## 🧠 Coesão

Cada função faz UMA coisa

```python
# ruim
def usuario_tudo(usuario):
print(usuario["nome"])
salvar_no_banco(usuario)

# bom
def mostrar(usuario):
print(usuario["nome"])

def salvar(usuario):
salvar_no_banco(usuario)
```

---

## 🔗 Acoplamento

Evitar dependência forte

```python
# ruim (acoplado)
def enviar_email():
servidor = Gmail() # preso nisso

# bom (desacoplado)
def enviar_email(servico_email):
servico_email.enviar()
```

---

## 🎭 Abstração

Esconder complexidade

```python
def salvar_usuario(usuario):
banco.inserir(usuario) # você não precisa saber como funciona
```

---

## 🔒 Encapsulamento

Proteger dados internos

```python
class Conta:
def __init__(self):
self._saldo = 0 # "protegido"

def depositar(self, valor):
self._saldo += valor

def ver_saldo(self):
return self._saldo
```

---

## 🧬 Composição

Construir com partes

```python
class Motor:
def ligar(self):
print("motor ligado")

class Carro:
def __init__(self):
self.motor = Motor() # composição

def ligar(self):
self.motor.ligar()
```

---

## 🏭 Pipeline

Etapas em sequência

```python
def etapa1(x): return x + 1
def etapa2(x): return x * 2
def etapa3(x): return x - 3

def pipeline(x):
x = etapa1(x)
x = etapa2(x)
x = etapa3(x)
return x
```

---

## 🔧 Extensibilidade

Adicionar sem quebrar

```python
class Plugin:
def executar(self):
pass

class PluginA(Plugin):
def executar(self):
print("A")

class PluginB(Plugin):
def executar(self):
print("B")
```

---

## 🛠️ Manutenibilidade

Código limpo = fácil de mexer

```python
# ruim
def calc(x,y):return x+y if x>0 else y

# bom
def somar(a, b):
return a + b
```

---

## 📊 Data-Driven

Dados controlam comportamento

```python
config = {
"multiplicador": 10
}

def calcular(x):
return x * config["multiplicador"]
```

---

## 👾 ECS (Entity Component System)

```python
# componentes
posicao = {"x": 10, "y": 20}
vida = {"hp": 100}

# entidade = conjunto
entidade = {
"posicao": posicao,
"vida": vida
}
```

---

## 🔄 State Machine

```python
estado = "parado"

def atualizar(entrada):
global estado

if estado == "parado" and entrada == "andar":
estado = "andando"
elif estado == "andando" and entrada == "pular":
estado = "pulando"
```

---

## 🎯 Determinismo

```python
def soma(x, y):
return x + y

# sempre igual
print(soma(2, 3)) # sempre 5
```

---

## 🧠 Cognitive Load

Código fácil de ler

```python
# ruim
x=1;y=2;z=x+y

# bom
numero1 = 1
numero2 = 2
resultado = numero1 + numero2
```

---

## 📍 Local Reasoning

Entender sem olhar tudo

```python
def dobrar(x):
return x * 2 # você entende só olhando aqui
```

---

## 🫗 Leaky Abstraction

Abstração “vazando”

```python
# parece simples
def ler_arquivo():
return open("file.txt").read()

# problema: pode dar erro se arquivo não existir 😬
```

Só tenho 378 pulls pra revisar....

Em breve quando for tarde alguns vão dizer: "Ah então era isso que os sionistas combatiam em Israel..."
Desconfie de quem fala sobre Irã mas não do povo persa que foi ENGOLIDO pela Sharia Islâmica. Ou dos 80 mil mortos pelo Regime Islâmico em 5 meses. Desconfie de quem chora pela morte de 90 Terroristas que os EUA ceifou. Pena que um Cidadão Brasileiro não pode perder sua cidadania. O Certo era Exilar/Despatriar e chutar para países islâmicos. Seus descendentes receberão a conta. Não acredito mais em justiça, mas talvez numa balança que D'us segura e se movimenta ao seu desejo de equilibrar as chacinas que nós provocamos... Quem mais matou nesse mundo? Tenho certeza que não foram Judeus ou Israelenses.

Sentinela agora tem um Bot no Telegram controlado pelo esquema do N8N, horários próprios e coisinhas mais.. hehe

"A calculadora blablabla"

👍

Sonhei com rabino yerachmiel, ele vindo aqui em casa, servia o rabino, ai ajudei ele a chegar até a cama para dormir, foi um sonho tão real como se ele fosse um pai e eu cuidando, mas ciente que era meu rabino e não um parente... mano q loucura... foi um sonho doce e agradável, mas real ao ponto de que estou estranho como se de fato a gente tivesse se encontrado, na minha mente ele veio passar o shabbat comigo... feliz, porem tremendo de medo. Yirat HaShem.

conectando supabase para que loja possa funcionar corretamente, essa é a parte mais assustadora do projeto, mexer com as coisas dos outros, o que o usuário comprar, etc. mermão q pic*

Poder usar Cache de cálculos/renderizações já efetuadas é algo muito apelão.

Compilar C++ e compilar o android tá sendo teste de paciência.

minha cabeça tá doendo, tô tão cansado que parece que o meu estado em economia de energia tá corroendo minha sanidade.

Exaustão no máximo. Sinto mt não responder ngm.

Lembrar disso aqui pra sempre:

sudo reflector \
--ipv4 \
--country Brazil \
--protocol https \
--age 12 \
--sort rate \
--save /etc/pacman.d/mirrorlist

Delícia. Tava fazendo download a 10kbp/s, ativei o reflector pulou pra 1mb. HEAIUEHAIEUH

Lembrar sempre.

Granularidade
Modularidade
Coesão
Acoplamento
Abstração
Encapsulamento
Composição
Pipeline
Extensibilidade
Manutenibilidade
Data-Driven
ECS
State Machine
Determinismo
Cognitive Load
Local Reasoning
Leaky Abstraction

Projeto tá tão grande que cada compilada é 1 min. [hj são mais 5/6 min]

É, HaShem trouxe, HaShem levou. Segue o baile.

Eu me tornarei fluente em hebraico. Que HaShem me permita um rápido e profundo aprendizado!