Forem: Reinan Br.

Criando um Docker Back End Pelo Celular

Reinan Br. — Mon, 11 Aug 2025 14:57:07 +0000

A quem diga, que só dá para programar usando um MacBook pro de 16k... Parafraseando o grande Toreto:
O importante não é o carro, mas sim quem o dirige.🏎️
Para iniciar o desenvolvimento no termux do Android, é preciso antes, ter instalado pelo menos o Ubuntu 24.04 no termux.
Com isso, vamos começar 📦.

Configurando Os Temas do Vim no Termux

Reinan Br. — Thu, 17 Oct 2024 13:31:46 +0000

Em certos casos, o coc do vim, apresenta temas que deixam a imagem do código não muito agradável para leitura. Neste artigo, iremos desenrolar de como podemos melhorar o tema do vim no Termux, usando como base, o artigo de um colega dev, phoenixnap.

Começamos primeiro, criando uma pasta no vim, que seja dedicado apenas para temas, com o seguinte comando:

mkdir -p ~/.vim/colors

Depois disso, iremos instalar o modulo do morhetz/gruvbox. Se você leu meu outro artigo de como instalar o autocomplete no vim, em que eu instalei o instalador de plugins no vim, já está pronto para seguir para o próximo passo.

Abra o vim adicione morhetz/gruvbox entre os módulos do seu vim, colocando no ~/.vimrc. Deve ficar algo parecido com isso:

Depois disso, salve com :wq, abra o ~/.vimrc e instale com : PlugInstall no interpretador do vim. Depois disso, você pode configurar do jeito que você que quiser, seguindo os passos do artigo do nosso colega phoenixnap, mas irei deixar o que mais me agradou:

"theme
hi Normal ctermfg=Red ctermbg=Black
syntax on colorscheme gruvbox

Ele deixa o terminal e o código assim:

Configurando o AutoComplete do Vim pelo Termux

Reinan Br. — Wed, 16 Oct 2024 13:03:21 +0000

Um guia prático de como ativar o autocomplete do vim.

O Vim pode parecer difícil para os que não o conhecem, devido ao meme de "como sair do Vim usando :q e Esc?!".

Embora existam várias lendas sobre o Vim, é preciso entender e aceitar que ele é realmente uma das melhores ferramentas para edição de código pelo terminal (se não a melhor).

Vamos agora iniciar um tutorial de como configurar o Vim com autocompletar no Termux.

Para instalar o Vim no Termux, precisamos primeiro executar o seguinte comando:

$ pkg i vim

Agora, instalar as configurações e linguagens nescessárias para um bom funcionamento dos plugins do vim:

pkg i git npm nodejs python3 golang php composer python3-jedi pylint

Instalando o nodejs atualizado:

# Download and install nvm:
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash

# in lieu of restarting the shell
\. "$HOME/.nvm/nvm.sh"

# Download and install Node.js:
nvm install 22

# Verify the Node.js version:
node -v # Should print "v22.18.0".
nvm current # Should print "v22.18.0".

# Verify npm version:
npm -v # Should print "10.9.3".

Agora, o Rust:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Depois, instale o plug-vim:

$ curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

Depois disso, vamos configurar o .vimrc para aceitar plugins e instalar o Coc, que será responsável pelo autocompletar nos códigos.

Usando o próprio Vim, insira o seguinte código no .vimrc:

$ vim ~/.vimrc # abrindo o código

Cole:

call plug#begin('~/.vim/plugged')
Plug 'neoclide/coc.nvim', {'branch': 'release'}
call plug#end()

Depois disso, salve, pressionando Esc e, logo em seguida, digitando :wq.

Em seguida, abra novamente e execute, fora do modo insert, o seguinte comando no Vim:

:PlugInstall

Após isso, saia do modo de instalação com :q. No modo insert, adicione as seguintes linhas no .vimrc para que ele funcione normalmente:

" Usar <Tab> para completar ou navegar nas sugestões
inoremap <silent><expr> <TAB>
      \ pumvisible() ? "\<C-n>" : "\<Tab>"
inoremap <silent><expr> <S-TAB>
      \ pumvisible() ? "\<C-p>" : "\<C-h>"

" Mapear Enter para selecionar a sugestão
inoremap <silent><expr> <CR> coc#pum#visible() ? coc#_select_confirm() : "\<CR>"

" Configuração de navegação usando setas
nmap <silent> [g <Plug>(coc-diagnostic-prev)
nmap <silent> ]g <Plug>(coc-diagnostic-next)

" Mostrar informações de erro e diagnósticos
nmap <silent> <leader>rn <Plug>(coc-rename)

" Formatar o código
nmap <silent> <leader>f <Plug>(coc-format)

Depois disso, use comandos no Vim como:

:CocInstall coc-python coc-java coc-tsserver coc-go

para instalar algumas linguagens, como esse comando que instala o autocompletar para Python, Java, TypeScript e Golang.

É preciso adaptar o Termux e o Vim para trabalhar com algumas linguagens.

Por exemplo, para Python, é necessário instalar o jedi antes, usando o pip. Quando abrir o primeiro arquivo Python no Vim, ele solicitará a instalação do pylint para poder ler as bibliotecas instaladas.

Seguindo esses passos, o Vim deve funcionar parecido com isso:

O .vimrc mais ideal para mim (que eu uso) é esse aqui.

call plug#begin('~/.vim/plugged')
" Plugin para sintaxe de Elixir
Plug 'elixir-editors/vim-elixir'

Plug 'neoclide/coc.nvim', {'branch': 'release'}
"Plug 'phpactor/phpactor', { 'do': 'composer install --no-dev -o' }
Plug 'Shougo/deoplete.nvim', { 'do': ':UpdateRemotePlugins' }
Plug 'othree/html5.vim'         " Suporte ao HTML5 (requisito)
Plug 'evanleck/vim-svelte', {'for': 'njk'} " Suporte básico a njk/nunjucks
Plug 'morhetz/gruvbox'
call plug#end()


autocmd BufNewFile,BufRead *.njk set filetype=htmldjango


"theme
hi Normal ctermfg=Red ctermbg=Black
syntax on colorscheme gruvbox


" config coc
inoremap <silent><expr> <TAB>
      \ pumvisible() ? "\<C-n>" : "\<Tab>"
inoremap <silent><expr> <S-TAB>
      \ pumvisible() ? "\<C-p>" : "\<C-h>"

" Mapear Enter para selecionar a sugestão
inoremap <silent><expr> <CR> coc#pum#visible() ? coc#_select_confirm() : "\<CR>"

" Configuração de navegação usando setas
nmap <silent> [g <Plug>(coc-diagnostic-prev)
nmap <silent> ]g <Plug>(coc-diagnostic-next)

" Mostrar informações de erro e diagnósticos
nmap <silent> <leader>rn <Plug>(coc-rename)

" Formatar o código
nmap <silent> <leader>f <Plug>(coc-format)

"teclas:wq





"theme
hi Normal ctermfg=Red ctermbg=Black
syntax on colorscheme gruvbox
"

" Melhorando o destaque de sintaxe
"set termguicolors
"syntax on
"colorscheme gruvbox

"Fundo escuro e contraste adequado
"theme
hi Normal ctermfg=Red ctermbg=Black
syntax on colorscheme gruvbox
"

" Melhorando o destaque de sintaxe
"set termguicolors
"syntax on
"colorscheme gruvbox

"Fundo escuro e contraste adequado
set termguicolors
syntax on
colorscheme gruvbox

" Fundo escuro e texto claro
hi Normal ctermfg=White ctermbg=Black

" Comentários
hi Comment ctermfg=Gray cterm=italic

" Palavras-chave (if, else, return, etc.)
hi Keyword ctermfg=Yellow cterm=bold

" Funções definidas pelo usuário
hi Function ctermfg=Blue cterm=bold

" Funções embutidas (ex: print, len, console.log)
hi BuiltinFunction ctermfg=LightBlue cterm=bold

" Métodos de classes
hi Method ctermfg=LightCyan cterm=bold

" Classes e Structs
hi Class ctermfg=Blue cterm=bold
hi Struct ctermfg=Blue cterm=bold

" Variáveis
hi Identifier ctermfg=Cyan
hi Variable ctermfg=LightCyan

" Parâmetros de funções e métodos
hi Parameter ctermfg=LightYellow

" Constantes e valores imutáveis
hi Constant ctermfg=LightBlue cterm=bold
hi Boolean ctermfg=LightMagenta
hi Number ctermfg=LightMagenta
hi String ctermfg=LightGreen

" Operadores (+, -, *, /, =, etc.)
hi Operator ctermfg=White cterm=bold

" Tipos (int, string, float, etc.)
hi Type ctermfg=Green cterm=bold
hi StorageClass ctermfg=Green cterm=bold

" Pré-processadores e diretivas (#define, import, require, etc.)
hi PreProc ctermfg=Magenta

" Caracteres especiais (como '\n', '\t')
hi Special ctermfg=Red

" Retorno de funções (ex: return, yield, etc.)
hi Return ctermfg=Yellow cterm=bold

" Exceções e erros (ex: throw, try, catch)
hi Exception ctermfg=Red cterm=bold

" Declarações de fluxo (for, while, break, continue)
hi Loop ctermfg=Yellow cterm=bold

" Erros e avisos
hi Error ctermfg=White ctermbg=DarkRed
hi Warning ctermfg=Black ctermbg=Yellow



hi MethodCall ctermfg=LightCyan cterm=bold

" Define cores para variáveis e chamadas de métodos separadamente
hi Variable ctermfg=Cyan
hi Method ctermfg=LightCyan cterm=bold

A História do Linux [0/7]: As Primeiras Linguagens de Programação e a Origem dos Primeiros Sistemas Operacionais

Reinan Br. — Sun, 05 May 2024 02:21:27 +0000

Com o advento dos primeiros sistemas complexos de interpretação de instruções mecânicas, surgiu a nescessidade de criar linhas de comandos que essas mesmas máquinas pudessem interpretar e reproduzir funções de acordo com o comando que foi dado e/ou que já foi pré guardado (armazenado ou programado) para a máquina fazer.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// Definição de estruturas para representar processos e memória
typedef struct Processo {
  int id;
  int tempo_execucao;
  int tempo_restante;
} Processo;

typedef struct Memoria {
  int tamanho;
  int espaco_livre;
  int enderecos[100]; // Array para armazenar endereços de processos alocados
} Memoria;

// Função para simular a alocação de memória para um processo
void alocarMemoria(Processo *processo, Memoria *memoria) {
  if (memoria->espaco_livre >= processo->tempo_execucao) {
    // Encontra um espaço livre na memória
    int endereco = 0;
    for (int i = 0; i < memoria->tamanho; i++) {
      if (memoria->enderecos[i] == 0) {
        endereco = i;
        break;
      }
    }

    // Atualiza as informações de processo e memória
    processo->endereco = endereco;
    memoria->espaco_livre -= processo->tempo_execucao;
    memoria->enderecos[endereco] = processo->id;
    printf("Processo %d alocado na memória no endereço %d.\n", processo->id, endereco);
  } else {
    printf("Memória insuficiente para alocar o processo %d.\n", processo->id);
  }
}

// Função para simular a execução de um processo
void executarProcesso(Processo *processo) {
  printf("Processo %d em execução...\n", processo->id);
  sleep(processo->tempo_execucao); // Simula o tempo de execução
  printf("Processo %d finalizado.\n", processo->id);
}

// Função para liberar memória alocada para um processo
void liberarMemoria(Processo *processo, Memoria *memoria) {
  memoria->espaco_livre += processo->tempo_execucao;
  memoria->enderecos[processo->endereco] = 0;
  printf("Memória liberada para o processo %d.\n", processo->id);
}

int main() {
  // Inicialização da memória
  Memoria memoria;
  memoria.tamanho = 100;
  memoria.espaco_livre = memoria.tamanho;
  for (int i = 0; i < memoria.tamanho; i++) {
    memoria.enderecos[i] = 0;
  }

  // Criação de alguns processos de exemplo
  Processo processo1 = {1, 30};
  Processo processo2 = {2, 20};
  Processo processo3 = {3, 15};

  // Simulação da alocação e execução de processos
  alocarMemoria(&processo1, &memoria);
  executarProcesso(&processo1);
  liberarMemoria(&processo1, &memoria);

  alocarMemoria(&processo2, &memoria);
  executarProcesso(&processo2);
  liberarMemoria(&processo2, &memoria);

  alocarMemoria(&processo3, &memoria);
  executarProcesso(&processo3);
  liberarMemoria(&processo3, &memoria);

  return 0;
}

A Vital Importância de Saber Trabalhar Com Mais de Uma Linguagem de Programação

Reinan Br. — Sun, 22 Oct 2023 14:06:36 +0000

No anime Naruto Shhippuden, existem diversos clans diferentes, cada um com um nivel de shakra (poder no anime) e habilidades diferentes. Cada um, com um jutsu bem diferenciado e mais forte do que outro.

Junto com eles, temos os poderes oculares. Que são uma das maneiras mais primordiais do anime de concentrar chakra.
O poder ocular mais famoso do anime, é sharingan.

E todos eles, todo o chakra presente no anime, veio de uma fonte singular, que foi a Kaguya, mãe de todos os chakras e poderes oculares na Terra.

Ela obteve todo esse poder, ao comer do fruto da Arvore Divina.

E dessa linhagem dela, e de outro ser que veio junto com ela, surgiram as diferentes linhagens presentes no anime, cada um tipo de poder e dominação diferente.

Mas por quê diabos começar o artigo falando da linhagem dos clãs de Naruto?
É simples, pequeno gafanhoto. Para poder entender essa analogia, devemos recorrer na história da programação, o mesmo caminho que usamos para poder compreender a diferença entre os clãs em Naruto.

A História das Linguagens de Programação

Original -> timeline Language

Podemos afirmar, que toda a história das liguagens de programação começou ainda na decada de 1940, em que a linguagem primordial (a raiz da Arvore Divina) foi a famosa linguagem de máquina, que nada mais eram do que os códigos binários, que eram diretamente programados e executados pelas máquinas na epóca. Programar nesse nível era extremamente complexo e propenso a erros.

Depois dela, na decáda de 1950 tivemos a linguagem como Assembly (o fruto da Arvore Divina), que representava instruções de máquina com abreviações mnemônicas. Isso tornou a programação um pouco mais legível, mas ainda estava intimamente ligada à arquitetura do hardware.

Logo em seguida, de grande impacto, na decáda de 1960, surgiu a linguagem de programação chamada Fortran (Clã Otsukisuki depois que comem os frutos da Arvore Divina), que viria a se tornar a principal linhagem de muitas das linguagens de programação que temos hoje, como, Perl, Swift, Go, rust, C e C++ que é por sua vez mãe do Python, Java e que por sua vez deu linhagem a linguagens como Kotlin, Dart e C#. O C influenciou na construção e design de diversas linguagens modernas, com detalhes de sintaxe e semântica, modelo de programação imperativa, construção por modulos, bibliotecas e APIs, portabilidade de códigos, alocação de memória manual, desempenho e entre outros pontos que vieram a influenciar de maneira direta e indireta na construção de outras linguagens.

Entre as várias assimilações e brincadeiras que podemos fazer e criar comparando o anime com a linhagem das linguagens de programação, eu escolhi fazer essa aqui:

Assim podemos ter uma compreensão bem mais didática (mesmo que pareça ser algo muito forçado como no meme acima) das origens e linhagem de cada linguagem de programação até aqui apresentadas (e de outras que nem iremos citar).

Diferentes linhagens, diferentes tipos de poderes.

Como todo fã desse anime sabe e conhece muito bem, cada linhagem de clã diferente possui um tipo/conjunto de poderes diferentes, em que esses poderes foram herdados de acordo com a sua experiência de vida e/ou linhagem de seus antepassados.
Por incrível que pareça, podemos fazer essa mesma analogia ao nível de produção e potência de cada linguagem e é exatamente este o ponto primordial desse artigo.

Como as linguagens possuem cada foco de produção diferentes e linhagens diferentes, sempre terá produções que uma irá conseguir fazer que outra ou não vai fazer de jeito nenhum ou não vai fazer no mesmo patamar de excelência de outra linguagem.

O que eu quero dizer com isso, pequeno gafanhoto, eu quero dizer, que assim como em Naruto, o grandioso Uchiha Madara, usou o hack de juntar o poder das 9 biju, e a linhagem de sangue de uchiha com ninju e assim vencer o time 7, (porque ele venceu mesmo, só foi traído pelo zetsu negro no final), você, como estudante iniciante de programação, tem que conhecer e saber produzir com mais de uma linguagem de programação diferente, pois assim, bem como o Madara, você estará de hack comparado a concorrência média. Para ser sincero, você estará de hack até só para você mesmo em suas produções pessoais no que lá for que você queira fazer. Pois, meu nobre, são muito poucos os que conseguem dominar diferentes linguagens com diferentes lógicas de sintese. Como uma colega de área mesmo disse, os que conseguem fazer isso, podem ser chamados de deuses (e eu consigo também, por isso que estou lhe escrevendo isso, para você ser também).

Com Grandes Poderes, Vem Grandes Vantagens Naturais

Ao passo que você tiver domínio sobre mais de 3 linguagens de kernel (linguagens propriamente ditas, como C/C++, Rust, GO, Python, Java ...) você vai conseguir ver de maneira nítida, a limitação de cada uma. Seja em sua sintaxe ou em sua produção. Você irá conseguir fluir facilmente de uma linguagem para outra, impedindo que qualquer das linguagens que você for usar atrapalhe sua produtividade.
Para grandes Devs, isso é um poder único e muito surreal.

Juntando esses poderes/linguagens então...

Quando começar este tipo de brincadeira, você talvez vai querer está que nem eu, escrevendo sobre a experiência e a importância desse tipo de poder.