## 🧱 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 😬
```
