DEV Community: Rômulo Mendes Soares Junior

Setup Django in Debian

Rômulo Mendes Soares Junior — Mon, 01 Sep 2025 23:15:24 +0000

1️⃣ Atualizar o sistema

sudo apt update && sudo apt upgrade -y

2️⃣ Instalar dependências básicas

sudo apt install -y python3 python3-pip python3-venv build-essential libssl-dev libffi-dev python3-dev git curl

Isso garante Python 3, pip, compiladores e libs necessárias para pacotes Python que usam C.

3️⃣ Criar um ambiente virtual (recomendado)

mkdir ~/meu_projeto
cd ~/meu_projeto
python3 -m venv venv
source venv/bin/activate

Sempre ative o ambiente virtual antes de instalar pacotes.

Para desativar:

deactivate

4️⃣ Atualizar pip e instalar Django

pip install --upgrade pip
pip install django

Verificar versão:

django-admin --version

5️⃣ Criar um projeto Django

django-admin startproject meu_projeto .

O ponto . cria o projeto na pasta atual.

6️⃣ Configurar banco de dados (opcional)

Por padrão o Django usa SQLite, que funciona bem para desenvolvimento.

Se quiser usar PostgreSQL (recomendado para produção):

sudo apt install -y postgresql postgresql-contrib libpq-dev

Criar usuário e banco:

sudo -u postgres createuser meu_usuario -P
sudo -u postgres createdb meu_banco -O meu_usuario

Instalar driver Python:

pip install psycopg2-binary

Configurar settings.py:

# meu_projeto/settings.py
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'meu_banco',
        'USER': 'meu_usuario',
        'PASSWORD': 'sua_senha',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

7️⃣ Aplicar migrações iniciais

python manage.py migrate

8️⃣ Criar usuário admin

python manage.py createsuperuser

Siga as instruções (nome, email, senha).

9️⃣ Testar servidor de desenvolvimento

python manage.py runserver

Acesse no navegador:

http://127.0.0.1:8000/

Admin:

http://127.0.0.1:8000/admin/

🔟 Configurar Django REST Framework (opcional)

Se quiser criar APIs:

pip install djangorestframework

Adicionar ao settings.py:

INSTALLED_APPS = [
    ...
    'rest_framework',
]

1️⃣1️⃣ Dicas extras

Para ambiente de produção, use Gunicorn + Nginx.
Use .env com python-decouple para variáveis sensíveis.
Sempre ative o virtualenv antes de rodar o projeto.

DTO, Value Object e Enum: a diferença que todo dev precisa saber 🚀

Rômulo Mendes Soares Junior — Thu, 21 Aug 2025 17:52:52 +0000


![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/19v3ldqsapwmfa2u4vck.png)

🎯 DTO, Value Object e Enum: a diferença que todo dev precisa saber

Quando você fala de DTO, Value Object e Enum juntos, você está falando de padrões de modelagem de dados ou, de forma mais acadêmica, de Data Modeling Patterns dentro da programação orientada a objetos e arquitetura de software.

📌 Em outras palavras:

DTO (Data Transfer Object) → caixa de correio 📦 (leva dados de um lugar a outro), padrão de transporte de dados.
Value Object → RG ou CPF 📑 (imutável, segue regras e validação própria), padrão de modelagem de valor (imutável, com regras próprias).
Enum → semáforo 🚦 (verde, amarelo, vermelho — valores fechados e conhecidos), tipo enumerado, um padrão para representar conjuntos fixos de estados ou valores.

Se quiser ir mais a fundar "la ele" sobre com exemplos praticos:

1️⃣ DTO - Data Transfer Object 📦
O que é:
Um DTO é um objeto simples, criado para transportar dados entre camadas da aplicação, por exemplo: Controller → Service → Repository.

Características:

Apenas transporta dados, sem lógica de negócio pesada.
Geralmente usado para sanitizar e validar entradas externas.
Pode ser mutável ou imutável, dependendo do design.

💡 Analogia: Pense no DTO como uma caixa de correio - ele leva informações de um lugar a outro.

2️⃣ Value Object - Representação de valor com regras 📑
O que é:
Um Value Object (VO) representa um conceito do domínio de forma imutável. Ele encapsula regras e comportamentos relacionados ao valor que carrega.

Características:

Imutável.
Igualdade por valor, não por identidade.
Pode validar ou manipular o próprio valor.

💡 Analogia: Pense no VO como seu RG ou CPF - ele é único, válido e não muda.

3️⃣ Enum - Valores fixos e conhecidos 🚦
O que é:
Um Enum é uma lista de valores pré-definidos, ideal para representar estados ou opções limitadas.

💡 Analogia: Pense no Enum como um semáforo - ele só pode estar em verde, amarelo ou vermelho.

📝 Resumo rápido:

DTO: transportar dados entre camadas 📦
Value Object: representar valores com regras e imutabilidade 📑
Enum: representar um conjunto fixo de estados ou opções 🚦

💡 Dica prática:
Em projetos bem estruturados (Laravel, DDD, Clean Architecture), você vai usar:

DTO para entrada/saída,
Value Objects para representar conceitos do domínio,
Enum para limitar estados ou opções.

Assim, seu código fica mais claro, seguro e fácil de manter.

How a Pool Game 🎱 Taught Me to Build Smart Schedules Using Genetic Algorithms 🧬 in PHP

Rômulo Mendes Soares Junior — Fri, 30 May 2025 18:40:08 +0000

The other day, I went out to relax and play a game of pool with my friend Romane.

In the middle of the game, he said:

“I thought I was clever—I just made a genetic search function!”

I thought he was joking… until he told me he built a function called buscaGenetica() that actually solved a real problem: paying bills with a limited budget.

💸 The Bill-Paying Problem

“Imagine a user provides an array of bills, each with an id and amount, and says they have $1,000 to pay as many as possible.”

He was using genetic algorithms to find the best possible combination under that constraint.

🧬 How Does Genetic Search Work?

His explanation sounded like science fiction:

💑 The bills “mated” with each other to produce new combinations.
🧟 Some generations had mutations, like swapped bills—what he jokingly called “genetic anomalies” (or "cancers" 😅).
👑 The best combinations survived into the next generation.
🧠 And this repeated for 100 generations, until the best solution emerged: the maximum number of bills paid with $1,000.

I was hooked. The concept was brilliant.

⏰ My Real-World Problem: Scheduling Availability

On the way home, I couldn’t stop thinking about it.

I’d been struggling with a problem in my own system:

I have several professionals with different skills (bathing, grooming, trimming), and I need to fill time slots with the best-suited professionals, without overlaps.

Then it clicked:

What if I applied Romane’s genetic algorithm to build that schedule?

I turned his logic into a PHP service called GeneticAlgorithmService.

💻 Implementing It in PHP

The GeneticAlgorithmService class is generic and takes a configuration object. It handles the entire evolution process under the hood:

use App\Services\GeneticAlgorithmService;

$config = [
    "items" => [
        ["id" => 1, "weight" => 10, "height" => 50, "value" => 60],
        ["id" => 2, "weight" => 20, "height" => 60, "value" => 100],
        ["id" => 3, "weight" => 30, "height" => 70, "value" => 120],
    ],
    "constraints" => [
        ["attribute" => "weight", "max" => 50],
        ["attribute" => "height", "max" => 110],
    ],
    "objective" => ["attribute" => "value", "goal" => "maximize"],
    "populationSize" => 50,
    "generations" => 100,
    "mutationRate" => 0.05,
    "eliteRate" => 0.2,
];

$configObject = json_decode(json_encode($config), false);
$service = new GeneticAlgorithmService($configObject);
$result = $service->run();

echo "Best combination found:\n";
print_r($result);

📥 Input (Configuration)

You define:

items: the data set (time slots, bills, tasks, etc.)
constraints: restrictions (e.g. max weight, time, height)
objective: which attribute to maximize or minimize
Genetic parameters: population size, number of generations, mutation rate, elite rate

📤 Output

The run() method returns something like:

[
    ['id' => 2, 'weight' => 20, 'height' => 60, 'value' => 100],
    ['id' => 1, 'weight' => 10, 'height' => 50, 'value' => 60]
]

In other words, the best possible combination based on your rules.

⚙️ What the Algorithm Does Under the Hood

The GeneticAlgorithmService internally runs:

Generates an initial population (random combinations)
Evaluates “fitness” (how good each combination is)
Selects top performers (elitism)
Crosses candidates (reproduction)
Randomly mutates offspring
Repeats this process across generations

✅ Why Does This Work So Well?

Because it’s flexible. With this pattern, you can solve:

Scheduling conflicts
Task prioritization
Resource allocation
Any combinatorial optimization problem

⚙️ The Full Algorithm

The complete source code for GeneticAlgorithmService is available in the full post. Feel free to adapt it to your own needs!

use Illuminate\Support\Collection;

class GeneticAlgorithmService
{
    private array $items;
    private array $constraints;
    private string $objectiveAttribute;
    private string $objectiveGoal; // 'maximize' or 'minimize'
    private int $populationSize;
    private int $generations;
    private float $mutationRate;
    private float $eliteRate;

    private array $population = [];

    public function __construct(object $config)
    {
        $this->items = $config->items;
        $this->constraints = $config->constraints;
        $this->objectiveAttribute = $config->objective->attribute;
        $this->objectiveGoal = $config->objective->goal;
        $this->populationSize = $config->populationSize;
        $this->generations = $config->generations;
        $this->mutationRate = $config->mutationRate;
        $this->eliteRate = $config->eliteRate;
    }

    // Runs the algorithm and returns the selected items
    public function run(): array
    {
        $this->initializePopulation();

        for ($gen = 0; $gen < $this->generations; $gen++) {
            $fitnessScores = $this->evaluatePopulation();

            $elite = $this->selectElite($fitnessScores);

            $newPopulation = $elite;

            while (count($newPopulation) < $this->populationSize) {
                $parent1 = $this->tournamentSelection($fitnessScores);
                $parent2 = $this->tournamentSelection($fitnessScores);

                $child = $this->crossover($parent1, $parent2);
                $this->mutate($child);

                if ($this->checkConstraints($child)) {
                    $newPopulation[] = $child;
                }
            }

            $this->population = $newPopulation;
        }

        $finalFitness = $this->evaluatePopulation();
        $bestIndex = $this->getBestIndex($finalFitness);

        return $this->decodeChromosome($this->population[$bestIndex]);
    }

    // Initializes the population with random chromosomes
    private function initializePopulation(): void
    {
        $this->population = [];
        $numItems = count($this->items);

        for ($i = 0; $i < $this->populationSize; $i++) {
            $chromosome = [];

            for ($j = 0; $j < $numItems; $j++) {
                // 0 or 1 to represent if the item is selected
                $chromosome[] = rand(0, 1);
            }

            // Ensure the chromosome respects all constraints
            if ($this->checkConstraints($chromosome)) {
                $this->population[] = $chromosome;
            } else {
                // If not, retry until a valid one is generated
                $i--;
            }
        }
    }

    // Evaluates the fitness of each individual in the population
    private function evaluatePopulation(): array
    {
        $fitnessScores = [];

        foreach ($this->population as $chromosome) {
            $fitnessScores[] = $this->fitness($chromosome);
        }

        return $fitnessScores;
    }

    // Fitness function to score each chromosome
    private function fitness(array $chromosome): float
    {
        $totalObjective = 0;

        foreach ($chromosome as $index => $gene) {
            if ($gene === 1) {
                $totalObjective += $this->items[$index][$this->objectiveAttribute];
            }
        }

        return $totalObjective;
    }

    // Selects the best individuals (elite) for the next generation
    private function selectElite(array $fitnessScores): array
    {
        $numElite = (int) round($this->populationSize * $this->eliteRate);

        // Pair each fitness score with its index
        $indexedFitness = array_map(fn($score, $i) => ['score' => $score, 'index' => $i], $fitnessScores, array_keys($fitnessScores));

        usort($indexedFitness, function ($a, $b) {
            if ($this->objectiveGoal === 'maximize') {
                return $b['score'] <=> $a['score'];
            }
            return $a['score'] <=> $b['score'];
        });

        $elite = [];
        for ($i = 0; $i < $numElite; $i++) {
            $elite[] = $this->population[$indexedFitness[$i]['index']];
        }

        return $elite;
    }

    // Tournament selection to pick a parent chromosome
    private function tournamentSelection(array $fitnessScores): array
    {
        $tournamentSize = 3;
        $candidates = [];

        $populationCount = count($this->population);

        for ($i = 0; $i < $tournamentSize; $i++) {
            $randomIndex = rand(0, $populationCount - 1);
            $candidates[] = ['chromosome' => $this->population[$randomIndex], 'fitness' => $fitnessScores[$randomIndex]];
        }

        usort($candidates, function ($a, $b) {
            if ($this->objectiveGoal === 'maximize') {
                return $b['fitness'] <=> $a['fitness'];
            }
            return $a['fitness'] <=> $b['fitness'];
        });

        return $candidates[0]['chromosome'];
    }

    // Single-point crossover between two parent chromosomes
    private function crossover(array $parent1, array $parent2): array
    {
        $length = count($parent1);
        $cut = rand(1, $length - 2);

        return array_merge(
            array_slice($parent1, 0, $cut),
            array_slice($parent2, $cut)
        );
    }

    // Mutation with a defined probability
    private function mutate(array &$chromosome): void
    {
        for ($i = 0; $i < count($chromosome); $i++) {
            if (rand() / getrandmax() < $this->mutationRate) {
                $chromosome[$i] = $chromosome[$i] === 1 ? 0 : 1;
            }
        }
    }

    // Checks if a chromosome respects all constraints
    private function checkConstraints(array $chromosome): bool
    {
        foreach ($this->constraints as $constraint) {
            $attribute = $constraint->attribute;
            $max = $constraint->max;

            $total = 0;
            foreach ($chromosome as $index => $gene) {
                if ($gene === 1) {
                    $total += $this->items[$index][$attribute];
                }
            }

            if ($total > $max) {
                return false;
            }
        }
        return true;
    }

    // Returns the index of the best chromosome based on fitness
    private function getBestIndex(array $fitnessScores): int
    {
        if ($this->objectiveGoal === 'maximize') {
            return array_keys($fitnessScores, max($fitnessScores))[0];
        }
        return array_keys($fitnessScores, min($fitnessScores))[0];
    }

    // Decodes a chromosome and returns the selected items
    private function decodeChromosome(array $chromosome): array
    {
        $selected = [];
        foreach ($chromosome as $index => $gene) {
            if ($gene === 1) {
                $selected[] = $this->items[$index];
            }
        }
        return $selected;
    }
}

🤖 Built in PHP, But the Intelligence is Universal

Although I built everything in pure PHP, the genetic algorithm logic is language-agnostic.

Whether you're using JavaScript, Python, Go, Rust, or any other language, you can rewrite the code manually—or let an AI like ChatGPT do the heavy lifting.

The intelligence is in the idea. The language is just the medium. 😉

🧠 Ready to Evolve?

If you’ve ever had to build a schedule, task list, or resource plan with overlapping constraints, you know brute force just doesn’t scale. Genetic algorithms mimic natural evolution to find surprisingly effective solutions.

And the best part? You can do it all in clean, testable, pure PHP.

Como uma conversa no bilhar 🎱 me ensinou a montar agendas com algoritmos genéticos 🧬 em PHP

Rômulo Mendes Soares Junior — Fri, 30 May 2025 18:22:28 +0000

Esses dias saí pra descontrair e jogar um bilhar com meu amigo Romane.

No meio do jogo, ele soltou:

“Eu que estava me achando porque fiz uma função de busca genética!”

Achei que ele estava brincando... até me contar que criou uma função chamada buscaGenetica() que ajudava a resolver um problema real: pagar boletos com um valor limitado.

💸 O problema dos boletos

“Imagine que o usuário informa um array de boletos, cada um com id e valor, e diz que possui R\$1.000 para pagar o maior número possível deles.”

Ele usava algoritmos genéticos para encontrar a melhor combinação possível respeitando esse limite.

🧬 Como funciona essa tal de busca genética?

A explicação dele foi tão lúdica que parecia até um roteiro de ficção científica:

💑 Os boletos “casavam” entre si e geravam novas combinações.
🧟 Algumas gerações vinham com mutações, tipo boletos trocados por outros — o que ele chamava carinhosamente de “anomalias genéticas” (ou "cânceres" 😅).
👑 Boas combinações sobreviviam direto para a próxima geração.
🧠 E tudo isso se repetia por 100 gerações, até encontrar a solução ideal: o maior número de boletos pagos com até R\$1.000.

Fiquei vidrado. A ideia era poderosa.

⏰ O meu problema real: disponibilidade de horários

Na volta pra casa, a conversa não saía da minha cabeça.

Eu estava justamente quebrando a cabeça com um problema no meu sistema:

Tenho vários profissionais, com diferentes habilidades (banho, tosa, trimming), e preciso preencher os horários da agenda com os melhores profissionais, sem sobreposição.

E aí veio o clique:

E se eu aplicasse o algoritmo genético do Romane para montar essa agenda?

Transformei a lógica dele em um serviço PHP chamado GeneticAlgorithmService.

💻 A implementação com PHP

A classe GeneticAlgorithmService é genérica e recebe um objeto de configuração. Ela cuida de toda a evolução genética por trás da solução:

use App\Services\GeneticAlgorithmService;

$config = [
    "items" => [
        ["id" => 1, "peso" => 10, "altura" => 50, "valor" => 60],
        ["id" => 2, "peso" => 20, "altura" => 60, "valor" => 100],
        ["id" => 3, "peso" => 30, "altura" => 70, "valor" => 120],
    ],
    "constraints" => [
        ["attribute" => "peso", "max" => 50],
        ["attribute" => "altura", "max" => 110],
    ],
    "objective" => ["attribute" => "valor", "goal" => "maximize"],
    "populationSize" => 50,
    "generations" => 100,
    "mutationRate" => 0.05,
    "eliteRate" => 0.2,
];

$configObject = json_decode(json_encode($config), false);
$service = new GeneticAlgorithmService($configObject);
$result = $service->run();

echo "Melhor combinação encontrada:\n";
print_r($result);

📥 Entrada (configuração)

Você define:

items: conjunto de dados (horários, boletos, tarefas, etc)
constraints: restrições (ex: peso máximo, limite de tempo, altura)
objective: qual atributo será maximizado ou minimizado
Parâmetros genéticos: tamanho da população, número de gerações, taxa de mutação e taxa de elite

📤 Saída

A função run() retorna, por exemplo:

[
    ['id' => 2, 'peso' => 20, 'altura' => 60, 'valor' => 100],
    ['id' => 1, 'peso' => 10, 'altura' => 50, 'valor' => 60]
]

Ou seja, a melhor combinação possível segundo os critérios definidos.

⚙️ O que o algoritmo faz por trás

Internamente, o GeneticAlgorithmService executa:

Geração da população inicial (combinações aleatórias de itens)
Avaliação de "fitness" (quão boa é cada combinação)
Seleção dos melhores indivíduos (elitismo)
Cruzamento entre candidatos (reprodução)
Mutação aleatória em descendentes
Repetição por várias gerações

✅ Por que isso funciona tão bem?

Porque é flexível. Com esse padrão, você pode resolver:

Agendas de atendimento
Seleção de tarefas com prioridades
Escalonamento de recursos
Qualquer problema de otimização combinatória

⚙️ O algoritmo completo

Abaixo está o código completo da classe GeneticAlgorithmService:

    use Illuminate\Support\Collection;

    class GeneticAlgorithmService
    {
        private array $items;
        private array $constraints;
        private string $objectiveAttribute;
        private string $objectiveGoal; // 'maximize' ou 'minimize'
        private int $populationSize;
        private int $generations;
        private float $mutationRate;
        private float $eliteRate;

        private array $population = [];

        public function __construct(object $config)
        {
            $this->items = $config->items;
            $this->constraints = $config->constraints;
            $this->objectiveAttribute = $config->objective->attribute;
            $this->objectiveGoal = $config->objective->goal;
            $this->populationSize = $config->populationSize;
            $this->generations = $config->generations;
            $this->mutationRate = $config->mutationRate;
            $this->eliteRate = $config->eliteRate;
        }

        // Executa o algoritmo e retorna a lista de itens selecionados
        public function run(): array
        {
            $this->initializePopulation();

            for ($gen = 0; $gen < $this->generations; $gen++) {
                $fitnessScores = $this->evaluatePopulation();

                $elite = $this->selectElite($fitnessScores);

                $newPopulation = $elite;

                while (count($newPopulation) < $this->populationSize) {
                    $parent1 = $this->tournamentSelection($fitnessScores);
                    $parent2 = $this->tournamentSelection($fitnessScores);

                    $child = $this->crossover($parent1, $parent2);
                    $this->mutate($child);

                    if ($this->checkConstraints($child)) {
                        $newPopulation[] = $child;
                    }
                }

                $this->population = $newPopulation;
            }

            $finalFitness = $this->evaluatePopulation();
            $bestIndex = $this->getBestIndex($finalFitness);

            return $this->decodeChromosome($this->population[$bestIndex]);
        }

        // Inicializa população com cromossomos aleatórios
        private function initializePopulation(): void
        {
            $this->population = [];
            $numItems = count($this->items);

            for ($i = 0; $i < $this->populationSize; $i++) {
                $chromosome = [];

                for ($j = 0; $j < $numItems; $j++) {
                    // 0 ou 1 para representar se o item está selecionado
                    $chromosome[] = rand(0, 1);
                }

                // Garante que o cromossomo respeite as restrições
                if ($this->checkConstraints($chromosome)) {
                    $this->population[] = $chromosome;
                } else {
                    // Caso não respeite, tenta gerar outro até encontrar válido
                    $i--;
                }
            }
        }

        // Avalia fitness de cada indivíduo na população
        private function evaluatePopulation(): array
        {
            $fitnessScores = [];

            foreach ($this->population as $chromosome) {
                $fitnessScores[] = $this->fitness($chromosome);
            }

            return $fitnessScores;
        }

        // Função fitness que calcula a pontuação do cromossomo
        private function fitness(array $chromosome): float
        {
            $totalObjective = 0;

            foreach ($chromosome as $index => $gene) {
                if ($gene === 1) {
                    $totalObjective += $this->items[$index][$this->objectiveAttribute];
                }
            }

            return $totalObjective;
        }

        // Seleciona os melhores indivíduos (elite) para a próxima geração
        private function selectElite(array $fitnessScores): array
        {
            $numElite = (int) round($this->populationSize * $this->eliteRate);

            // Associa fitness ao índice para ordenar
            $indexedFitness = array_map(fn($score, $i) => ['score' => $score, 'index' => $i], $fitnessScores, array_keys($fitnessScores));

            usort($indexedFitness, function ($a, $b) {
                if ($this->objectiveGoal === 'maximize') {
                    return $b['score'] <=> $a['score'];
                }
                return $a['score'] <=> $b['score'];
            });

            $elite = [];
            for ($i = 0; $i < $numElite; $i++) {
                $elite[] = $this->population[$indexedFitness[$i]['index']];
            }

            return $elite;
        }

        // Torneio para selecionar um cromossomo (parent)
        private function tournamentSelection(array $fitnessScores): array
        {
            $tournamentSize = 3;
            $candidates = [];

            $populationCount = count($this->population);

            for ($i = 0; $i < $tournamentSize; $i++) {
                $randomIndex = rand(0, $populationCount - 1);
                $candidates[] = ['chromosome' => $this->population[$randomIndex], 'fitness' => $fitnessScores[$randomIndex]];
            }

            usort($candidates, function ($a, $b) {
                if ($this->objectiveGoal === 'maximize') {
                    return $b['fitness'] <=> $a['fitness'];
                }
                return $a['fitness'] <=> $b['fitness'];
            });

            return $candidates[0]['chromosome'];
        }

        // Crossover simples: um ponto de corte
        private function crossover(array $parent1, array $parent2): array
        {
            $length = count($parent1);
            $cut = rand(1, $length - 2);

            return array_merge(
                array_slice($parent1, 0, $cut),
                array_slice($parent2, $cut)
            );
        }

        // Mutação com probabilidade definida
        private function mutate(array &$chromosome): void
        {
            for ($i = 0; $i < count($chromosome); $i++) {
                if (rand() / getrandmax() < $this->mutationRate) {
                    $chromosome[$i] = $chromosome[$i] === 1 ? 0 : 1;
                }
            }
        }

        // Verifica se o cromossomo respeita as restrições
        private function checkConstraints(array $chromosome): bool
        {
            foreach ($this->constraints as $constraint) {
                $attribute = $constraint->attribute;
                $max = $constraint->max;

                $total = 0;
                foreach ($chromosome as $index => $gene) {
                    if ($gene === 1) {
                        $total += $this->items[$index][$attribute];
                    }
                }

                if ($total > $max) {
                    return false;
                }
            }
            return true;
        }

        // Retorna o índice do melhor cromossomo baseado no fitness
        private function getBestIndex(array $fitnessScores): int
        {
            if ($this->objectiveGoal === 'maximize') {
                return array_keys($fitnessScores, max($fitnessScores))[0];
            }
            return array_keys($fitnessScores, min($fitnessScores))[0];
        }

        // Decodifica o cromossomo para retornar os itens selecionados
        private function decodeChromosome(array $chromosome): array
        {
            $selected = [];
            foreach ($chromosome as $index => $gene) {
                if ($gene === 1) {
                    $selected[] = $this->items[$index];
                }
            }
            return $selected;
        }
    }

🤖 Feito em PHP. Mas a inteligência é universal.

Embora eu tenha feito tudo isso com PHP, a lógica do algoritmo genético é agnóstica.

Se quiser usar JavaScript, Python, Go, Rust ou qualquer outra linguagem, você pode traduzir o código manualmente ou usar uma IA como o ChatGPT para converter tudo.

A inteligência está na ideia. A linguagem é só o meio. 😉

🧠 Pronto para evoluir?

Se você já precisou montar uma escala, agenda ou lista de prioridades com muitas variáveis cruzadas, sabe que usar força bruta é lento ou inviável. Algoritmos genéticos simulam a evolução natural para encontrar soluções surpreendentemente boas.

E o melhor: com PHP puro, de forma testável, limpa e extensível.