Updates on readme

Author: abmBispo

README.md

@@ -8,14 +8,18 @@ O motivo principal pelo qual resolvi desenvolver essa fila de processos foi o ap
 A `Application`desta fila de processos possui duas funções extremamente relevantes: supervisionar os processos que irão criar/consumir a fila e inciar de 1 a quantidade `System.schedulers_online` processos dinâmicos, os chamados workers, sob a supervisão de `ElixirQueue.WorkerSupervisor`. Eis os filhos da `ElixirQueue.Supervisor`:
 
 ```ex
-    children = [
-      {ElixirQueue.Queue, name: ElixirQueue.Queue},
-      {DynamicSupervisor, name: ElixirQueue.WorkerSupervisor, strategy: :one_for_one},
-      {ElixirQueue.WorkerPool, name: ElixirQueue.WorkerPool},
-      {ElixirQueue.EventLoop, []}
-    ]
+children = [
+  {ElixirQueue.Queue, name: ElixirQueue.Queue},
+  {DynamicSupervisor, name: ElixirQueue.WorkerSupervisor, strategy: :one_for_one},
+  {ElixirQueue.WorkerPool, name: ElixirQueue.WorkerPool},
+  {ElixirQueue.EventLoop, []}
+]
 ```
 Os filhos, de cima para baixo, representam as seguintes estruturas: `ElixirQueue.Queue` é o `GenServer` que guarda o estado da fila numa tupla; `ElixirQueue.WorkerSupervisor`é o `DynamicSupervisor` dos _workers_ adicionados dinamicamente sempre igual ou menor que o número de `schedulers` onlines; `ElixirQueue.WorkerPool`, o processo responsável por guardar os `pids` dos _workers_ e os _jobs_ executados, quer seja com sucesso ou falha; e por último o `ElixirQueue.EventLoop` que é a `Task` que "escuta" as mudanças na `ElixirQueue.Queue` (ou seja, na fila de processos) e retira _jobs_ para serem executados. O funcionamento específico de cada módulo eu explicarei conforme for me parecendo útil.
+### ElixirQueue.EventLoop
+Eis aqui o processo que controla a inserção de elementos na fila. Um _event loop_ por padrão é uma função que executa numa iteração/recursão _pseudo infinita_, uma vez que não existe a intenção de se quebrar o _loop_. A cada ciclo o _loop_ busca _jobs_ adicionados na fila - ou seja, de certa forma o `ElixirQueue.EventLoop` "escuta" as alterações que ocorreram na fila e reage a partir desses eventos - e os direciona ao `ElixirQueue.WorkerPool` para serem executados. Este módulo assume o _behaviour_ de `Task` e sua única função (`event_loop/0`) não retorna nenhum valor tendo em vista que é um _loop_ eterno: ela busca da fila algum elemento e pode receber ou uma tupla `{:ok, job}` com a a tarefa a ser realizada ou uma tupla `{:error, :empty}` para caso a fila esteja vazia; no primeiro caso ele envia para o `ElixirQueue.WorkerPool` a tarefa e executa `event_loop/0` novamente; no segundo caso ele apenas executa a própria função recursivamente, continuando o loop até encontrar algum evento relevante (inserção de elemento na fila).
+### ElixirQueue.Queue
+O módulo `ElixirQueue.Queue` guarda o coração do sistema. Aqui os _jobs_ são enfileirados para serem consumidos mais tarde pelos _workers_. É um `GenServer` sob a supervisão da `ElixirQueue.Application`, que guarda uma tupla como estado e nessa tupla estão guardados os jobs - para entender o porquê eu preferi por uma tupla ao invés de uma lista encadeada (`List`), mais abaixo em **Análise de Desempenho** está explicado. A `Queue` é uma estrutura bem simples, com funções triviais que basicamente limpam, buscam o primeiro elemento da fila para ser executado e insere um elemento ao fim da fila, de forma a ser executado mais tarde, conforme inserção.
 
 ## Análise de comportamento assintótico