Neste artigo eu trago algumas dicas de como se comportar no ambiente profissional que são particularmente valiosas para uma profissional de tecnologia e que se aplicam principalmente às profissões de desenvolvedora de software, analista de testes, analista de dados, cientista de dados, devops e suporte técnico. Estas dicas são particularmente úteis para quem está no começo da carreira e ainda precisa se adaptar ao mundo do trabalho na tecnologia.

Aqui você vai encontrar dicas sobre como colaborar com o restante do time de maneira a otimizar o trabalho de todo mundo, reduzir o estresse e aumentar a satisfação no dia a dia de trabalho.

Em diversas situações a gente pode precisar utilizar variáveis de ambiente, alguns exemplos incluem:

• Alterar o comportamento do software através de Feature flags

• Dar acesso a segredos e chaves de API
• Personalizar a configuração do software - por exemplo, alterar a porta de um servidor

Para facilitar o aprendizado, eu montei um vídeo bem simples pra explicar tudo o que está aqui no artigo:

Como ler variáveis de ambiente com Rust utilizando a biblioteca padrão

Rust possui uma biblioteca padrão bem completinha, que é a std. Para acessar variáveis de ambiente utilizando esta biblioteca, você pode utilizar a função std::env::var() e o seu tipo de retorno é um objeto do tipo Result<String, VarError>.

Então para obter uma variável de ambiente chamada SERVER_PORT podemos fazer algo como o seguinte:

fn main() {
  let port = std::env::var("SERVER_PORT").unwrap_or("8080".to_string());
  
  println!("A porta e {}", port);
}

Repare que como o retorno é do tipo Result<String, VarError> você pode utilizar a função unwrap_or() para definir um valor padrão caso a variável não esteja presente. Portanto ao rodar o programa, temos as seguintes saídas:

$ cargo run
A porta e 8080

$ SERVER_PORT=9090 cargo run
A porta e 9090

Como ler variáveis de ambiente em tempo de compilação com Rust

As vezes é importante mudar o comportamento do software em tempo de compilação e mantê-lo fixo durante o tempo de execução, por exemplo criar um comportamento diferente para ambientes Windows e Linux, ou utilizando o X11 ou Wayland.

Para fazer algo assim, também é possível utilizar variáveis de ambiente porém precisamos utilizar a macro env!() que retorna um &'static str. É importante notar que quando a macro env! é utilizada, a variável de ambiente precisa estar presente no momento da compilação - caso contrário um erro de compilação ocorre. Veja:

fn main() {
  let default_port = env!("DEFAULT_SERVER_PORT");
  
  println!("A porta padrao e {}", default_port);
}

Ao compilar sem a variável de ambiente:

$ cargo build

error: environment variable `DEFAULT_SERVER_PORT` not defined at compile time

E ao compilar com a variável de ambiente definida e rodar o programa (que se chama rust-env no meu exemplo):

$ DEFAULT_SERVER_PORT=8080 cargo build
$ ./target/debug/rust-env

A porta padrao e 8080

$ DEFAULT_SERVER_PORT=9090 ./target/debug/rust-env

A porta padrao e 8080

Repare que ao rodar o binário, mesmo que a variável DEFAULT_SERVER_PORT seja redefinida, o software não a utiliza. Isto porque a macro env! só opera em tempo de compilação.

Para escrever tutoriais sobre VIM eu preciso sempre garantir que os comandos que eu utilizo funcionariam em qualquer ambiente VIM, independente de configurações e plugins. E para isso é necessário executar o programa ignorando todas as customizações.

Neste artigo eu vou te mostrar como iniciar o VIM ignorando quaisquer plugins, configurações ou customizações que estejam em seu computador.

Para abrir o VIM sem plugins ou configurações basta utilizar a flag --clean ao abrir o programa, como na linha a seguir:

$ vim --clean

Para abrir um arquivo com o VIM sem utilizar plugins ou configurações podemos utilizar também a flag --clean, como na linha de comando abaixo:

$ vim --clean nomedoarquivo.txt

O que diz o manual?

O manual oficial do editor VIM indica que a opção --clean causa o seguinte efeito:

--clean: Do not use any personal configuration (vimrc, plugins, etc.). Useful to see if problem reproduces with a clean Vim setup.

Em tradução (minha) significa o seguinte:

--clean: Não utilizar nenhuma configuração pessoal (vimrc, plugins, etc.). Útil para verificar se um problema pode ser reproduzido com uma configuração limpa do Vim.

Portanto sempre que escrevo artigos sobre VIM é útil a flag --clean para que nenhum comportamento seja específico do meu computador e possa funcionar para qualquer pessoa que siga os mesmos passos.

Aprender a programar pode ser uma jornada desafiadora, mas  recompensadora. É uma habilidade essencial em um mundo cada vez mais digital e tecnologicamente avançado.

Se você está interessado em dar os primeiros passos no mundo da programação, este pequeno artigo lhe dará algumas dicas sobre como começar e como superar problemas que você possa encontrar ao longo do caminho. 

1 – Selecione a linguagem de programação

Um dos primeiros desafios para iniciantes é decidir qual linguagem de programação aprender. Existem várias opções como PHP, Python, Java, JavaScript, C, etc, e para conseguir escolher qual caminho seguir considere seus objetivos e interesses.

Por exemplo, Python é uma linguagem popular para iniciantes devido à sua simplicidade e ampla aplicabilidade.

2 – Encontre recursos de aprendizado

Existem muitos recursos disponíveis para aprender programação, como livros, tutoriais em vídeo, cursos online e plataformas interativas, e acredite, a quantidade de informações pode ser esmagadora. Pensando nisso, você pode escolher recursos de aprendizagem adequados ao seu estilo e que permitam a passagem gradual do nível básico ao avançado.

Para tornar a jornada do aprendizado mais divertida e eficiente, a dica é encontrar recursos que combinem com o seu estilo. Aqui não existe uma fórmula mágica única! Você pode escolher os materiais que melhor se adaptam às suas preferências e ritmo de aprendizagem.

No site da Codamos tem um guia que começa pelo entendimento da mecânica da linguagem (sintaxe). É como aprender a linguagem nativa dos computadores!

3 – Entenda os conceitos básicos

Conceitos como variáveis, loops, condições e funções são essenciais em qualquer linguagem de programação. Esse conceito pode parecer difícil de entender a princípio, mas  a chave para superar essa dificuldade é a prática.

Comece com pequenos exercícios e projetos simples para colocar esses conceitos em prática.

4 – Como lidar com a decepção

A programação pode ser difícil e as falhas ao longo do caminho são comuns – e tá tudo bem 😉. Ficar preso em um problema por horas pode ser frustrante, mas é importante lembrar que a solução de problemas é uma parte essencial da programação.

Não tenha medo de procurar ajuda em comunidades de programadores online ou fóruns especializados. Profissionais de software de todos os níveis têm muito a ganhar ao participar de comunidades: iniciantes ganham exposição a ideias e discussões de alto nível, enquanto pessoas mais experientes trocam entre si e ganham experiência como mentoras.

5 – Exercite-se regularmente

Consistência é a chave para aprender a programar. Reserve um tempo  para praticar e codificar regularmente, mesmo que  por um curto período de tempo todos os dias.

A prática contínua reforça os conceitos aprendidos e ajuda a desenvolver habilidades de resolução de problemas. Uma dica legal é o site da FreeCodeCamp onde são apresentados desafios curtinhos  com explicação a cada passo.

6 – Crie seu projeto pessoal

Além de se exercitar e treinar, é importante trabalhar em projetos pessoais. Criar algo com o qual você se preocupa torna o aprendizado mais motivador e divertido, e para começar não precisa ser nada muito mirabolante.

Comece com projetos simples e aumente a complexidade à medida que ganhar confiança. Quer ver um projeto bacana para quem está iniciando? Confere este video aqui:

7 – Colabore com outros programadores

Participar de uma comunidade de desenvolvimento ou colaborar com outras pessoas em um projeto pode ser uma experiência inestimável. Além de aprender com os outros, você  pode obter feedback e insights que o ajudarão a melhorar suas habilidades.  E se eu puder aqui puxar a brasa para a minha sardinha, recomendo fortemente as comunidades da Codamos e o PHPSP.

Para descobrir diferentes comunidades você pode dar uma olhada neste artigo que tem uma lista bem bacana de comunidades de programação brasileiras.

8 – Adaptação às novas tecnologias

O universo da programação está em constante evolução e novas tecnologias e tendências aparecem todos os dias. Esteja preparado para aprender coisas novas e acompanhar as mudanças para superar esses desafios.

Minha conclusão?

Começar a programar pode ter alguns desafios, mas é uma habilidade valiosa e gratificante. Escolher a linguagem que mais atende suas expectativas, encontrar bons materiais de estudo, praticar regularmente, frustrar-se (e é sim importante, faz parte do crescimento) e trabalhar em projetos pessoais são algumas das estratégias para vencer os obstáculos nessa jornada.

Lembre-se: a chave para o sucesso está na persistência e no equilíbrio entre teoria e prática. Prepare-se para desbravar novos horizontes e descobrir todo o potencial que a programação oferece.

Boa sorte e divirta-se nessa jornada!

É muito comum, quando a gente começa a trabalhar com GIT, de não entendermos alguns conceitos simples. Coisas que a gente precisa configurar uma única vez na vida e nunca mais vê. E aí quando formatamos o computador ou trocamos de equipamento essas dúvidas sempre voltam.

Uma dúvida comum que eu tinha quando estava iniciando e que recebo várias vezes por mês de pessoas que eu acompanho os estudos, é “Por que quando eu subo arquivos no github a minha foto não aparece na lista de commits?” – e isto acontece porque na hora de fazer o commit o seu usuário e email não estavam configurados e portanto a assinatura não saiu como o esperado.

Neste artigo vamos ver exatamente como configurar seu usuário e e-mail do GIT em sua máquina local para corrigir as assinaturas de seus commits.

Por que minha foto não aparece nos commits do Github ou Gitlab?

Porque o GIT em sua máquina não está configurado com o mesmo e-mail do seu perfil no Github ou Gitlab.

Sempre que nós fazemos um commit, como explicamos no artigo como subir arquivos pro seu projeto no Github, a ferramenta GIT não apenas armazena as alterações como assina com o seu usuário atual. Veja na imagem abaixo uma assinatura de commit:

Portanto para a sua foto aparecer na lista de commits dessas plataformas, é importante configurar o seu nome de usuário e e-mail corretamente.

Como configurar usuário e e-mail do GIT

O usuário e e-mail associado ao git podem ser configurados para todos seus projetos de uma única vez utilizando o comando git config e passando a flag --global.

Para definir o seu e-mail de assinatura GIT, rode o comando abaixo:

$ git config --global user.email "[email protected]"

Desta forma todos os commits que vocie escrever daqui em diante serão assinados com o e-mail “[email protected]”. De forma semelhante, podemos alterar o nome de usuário GIT da seguinte maneira:

$ git config --global user.name "seuusuario"

Você pode verificar que as suas configurações tomaram efeito rodando o mesmo comando com a flag --list:

$ git config --list
...
[email protected]
user.name=seuusario

Como configurar um usuário e e-mail diferente para um repositório específico

Pode acontecer de num mesmo computador você precisar utilizar duas contas de GIT diferentes. Por exemplo, caso você utilize o mesmo computador para trabalho e para projetos pessoais. Ou caso preste consultoria a diferentes empresas.

Além de definir a configuração global do GIT com o comando git config --global, que se aplica a todos os repositórios GIT em seu computador, é possível alterar configurações apenas para o projeto atual através da flag --local:

$ git config --local user.email "[email protected]"
$ git config --local user.name "seuoutrousuario"

Os comandos acima apenas funcionarão se o seu diretório atual for um repositório GIT.

Conclusão

A gente viu como alterar seu usuário e e-mail de assinatura de commits do GIT através do comando git config. Com isso você vai poder resolver seu problema de identificação de commits mais facilmente.

Se você já fez um commit que não estava assinado corretamente e quer corrigí-lo, dê uma olhada neste outro artigo sobre como renomear mensagens de commit em um repositório para ter uma outra chance de assinar aqueles commits.

Se você programa ou está aprendendo PHP há algum tempo já deve ter visto um erro na sua tela ou arquivo de log que diz algo mais ou menos assim:

PHP Notice: Use of undefined constant nome - assumed 'nome' in /var/www/index.php on line 10

Hoje nós vamos falar sobre este erro, como identificar e corrigir de forma segura. Vem comigo!

Por que “Use of undefined constant” acontece?

Quando nós fazemos referência a uma constante que não foi declarada, o PHP decide que em vez de te devolver uma tela em branco ou com erros é melhor entender que você quis dizer que aquilo era uma string. É uma estratégia de melhor esforço (best effort) em vez de falhar cedo (fail first).

O erro Use of undefined constant acontece porque o PHP tenta perdoar uma falha que nós cometemos enquanto escrevemos um código ao não colocar strings entre aspas.

Por exemplo, o código abaixo funciona:

$arr = ["nome" => "Nawarian"];
echo $arr[nome];
// PHP Notice:  Use of undefined constant nome - assumed 'nome' in ...
// Nawarian

O código acima vai justamente gerar um erro Use of undefined constant nome - assumed 'nome' in .... Isto porque ao acessar a chave nome do array $arr não utilizamos uma string 'nome' mas sim uma constante nome que nunca foi declarada.

O PHP então perdoa este erro que cometemos e entende que estamos tentando fazer echo $arr['nome']. Mas como isto pode ter sido um erro da nossa parte, o PHP gera um erro do tipo notice que nos permite averiguar aquele pedaço de código para corrigirmos ou mesmo identificarmos bugs.

Como corrigir o erro “Use of undefined constant”?

O erro Use of undefined constant acontece, na maioria dos casos, porque tentamos utilizar uma string mas esquecemos de colocar as aspas. Nestes casos o ideal é corrigir o problema colocando aspas na palavra.

Por exemplo ao acessar a chave “pessoa” do array “arr” o seguinte código $arr[pessoa] gera erro mas funciona, enquanto o código $arr['pessoa'] funciona da mesma forma e sem erros.

Atenção! Em alguns casos pode ser que a intenção da pessoa que escreveu aquela linha fosse realmente de referenciar uma constante que foi definida em outro arquivo e nunca foi importada. Neste caso o correto não é transformar em string, mas sim fazer o include do arquivo que define a constante.

Como ler a mensagem de erro “Use of undefined constant”

Esta mensagem normalmente fica no seu arquivo error.logmas também pode ser enviada diretamente na tela em ambiente de desenvolvimento.

O template da mensagem é o seguinte:

PHP Notice:  Use of undefined constant <NOME> - assumed '<NOME>' in <ARQUIVO> on line <LINHA>

Vamos quebrar esta mensagem em partes:

PHP Notice: o tipo do erro que aconteceu de acordo com os níveis de erros da linguagem PHP.

Use of undefined constant <NOME>: indica que no código a constante <NOME> foi referenciada mas nunca foi definida. Deixa eu clarificar o que isso significa com o código a seguir:

const PESSOA = 'nawarian';
$arr = [
  'nawarian' => 'programador',
  'nickolas' => 'trabalhador'
];

echo $arr[PESSOA]; // programador
echo $arr[nickolas]; // Notice
echo $arr['nickolas']; // trabalhador

No exemplo acima $arr[PESSOA] não gera erro, porque a constante PESSOA foi definida na primeira linha do código. Já a linha $arr[nickolas] gera um erro Use of undefined constant nickolas porque estamos fazendo referência a uma constante nickolas que nunca foi declarada. Note que o correto neste caso é utilizar $arr['nickolas'].

assumed ‘<NOME>' in <ARQUIVO> on line <LINHA>: aqui temos a decisão que o PHP tomou por você: utilizar uma string em vez de constante. Como em $arr[nickolas] que vira $arr['nickolas'].

O PHP também te indica qual o nome do arquivo em que este problema aconteceu, e em qual linha. Desta forma você pode inspecionar o arquivo e verificar se este é realmente o comportamento que você gostaria que a sua aplicação tivesse.

Como identificar onde o “Use of undefined constant” ocorre?

Ao navegar pelo seu sistema você provavelmente vai gerar alguns erros. Estes erros são escritos num arquivo de log, normalmente chamado error.log. O caminho onde este arquivo é escrito fica definido na variável error_log do php.ini, você pode verificar o caminho tanto no php.ini quando utilizando a função phpinfo().

Ao verificar o arquivo error.log você pode buscar pelo texto “Use of undefined constant” e vai encontrar diferentes linhas com este erro. Leia o fim da linha e repare que ela tem o formato in /caminho/para/arquivo.php on line 100. Ora, é justamente aqui que você entende qual arquivo PHP está gerando este erro, e qual a linha em que ele acontece.

Consequências do erro “Use of undefined constant”

É importante que a gente seja sempre 100% intencional sobre o código que escrevemos. Eu escrevi sobre isso no artigo sobre programação por coincidência e como escrever códigos que outras pessoas entendem.

Uma das consequências do Use of undefined constant é que o nosso código fica mais imprevisível, porque nós permitimos que o PHP altere o comportamento do nosso código. Isto pode gerar falhas de software que se manifestam das formas mais estranhas possíveis. Além do mais, ao atualizar a versão do PHP pode acontecer de a nova versão remover este comportamento completamente.

Outra consequência disso é que o nosso arquivo de logs de erro fica poluído com mensagens do tipo Use of undefined constant. Estas mensagens não precisam existir porque o seu código está funcionando, só que não da forma como você o escreveu. Ao poluir o log com mensagens deste tipo, você perde a capacidade de prestar atenção em erros que realmente podem significar uma falha importante no seu sistema.

A última consequência que quero citar aqui é a da utilização de disco indevida. Eu já trabalhei com aplicações que para cada página acessada geravam-se cerca de 30 mil linhas de log do tipo Use of undefined constant. Isto gera uma superutilização de disco desnecessária e pode inclusive gerar problemas de manutenção em seus servidores e o aumento de custo de armazenamento.

O que é um array no PHP?

array é um dos diversos tipos de dados que a linguagem PHP oferece. É uma forma de armazenar vários valores numa única variável. Numa única variável $numeros nós podemos armazenar 5 números de uma vez só, como no exemplo a seguir:

/*
 * A variável $numeros possui os 5 valores listados
 * dentro dos colchetes: 4, 3, 2, 1 e 0.
 */
$numeros = [4, 3, 2, 1, 0];

Desta forma é possível acessar estes valores através da sintaxe de colchetes. Ainda considerando a variável $numeros que criamos acima, podemos acessar cada elemento como no trecho de código a seguir:

echo "O segundo elemento é: " . $numeros[1];
// O segundo elemento é: 3

Note que o valor $numeros[1] faz referência ao segundo valor que colocamos entre colchetes ao criar a variável $numeros, o número inteiro 3.

De forma parecida a gente pode acessar o valor $numeros[0] (inteiro 4) ou $numero[3] (inteiro 1).

O array do PHP é mais poderoso que o de outras linguagens

É importante notar que o array do PHP é muito mais flexível e poderoso do que em diversas outras linguagens, dada a natureza do sistema de tipos que o PHP oferece. Isto porque o array do PHP pode se comportar como vetor, lista, pilha, fila, tupla ou dicionário. Tudo num único tipo, integrado com diferentes aspectos da linguagem.

Para efeito de comparação, vamos ver o quão poderoso o tipo array é comparado com conceitos de outras linguagens:

É claro que nem tudo são flores, e o array do PHP não é melhor em absolutamente TUDO quando comparado a outras linguagens. O map<I,T> do C++ por exemplo consegue garantir o tipo interno dos dados, enquanto em PHP é necessário fazer algumas verificações adicionais em código ou via análise estática com ferramentas como o PHPStan.

Como criar arrays de índice numérico ou do tipo lista em PHP?

Para criar um arrayde índice numérico, ou vetor, basta omitir as chaves e passar apenas valores para o array entre colchetes ([ e ]).

No exemplo abaixo vamos criar um array de índice numérico com 3 frutas: banana, maçã e manga:

$frutas = ['manga', 'maçã', 'banana'];

echo $frutas[0]; // manga
echo $frutas[1]; // maçã
echo $frutas[2]; // banana

Podemos notar algumas coisas:

• Acessamos cada elemento através de seu índice usando a sintaxe de colchetes;

• Os índices estão em ordem crescente, começando em 0 (zero);

• Os elementos (banana, maçã e manga) não são ordenados alfabeticamente mas por ordem de inserção

manga é o primeiro elemento, portanto recebe o índice 0. maçã é o segundo, recebe o índice 1. banana é o terceiro elemento e recebe o índice 2.

Na linguagem PHP, em contrates com Java ou C/C++, é possível misturar tipos dentro de um vetor. O exemplo a seguir é um código válido:

$balaio = ['comida de gato', new Gato(), false];

Independentemente de como usaríamos este vetor, temos a flexibilidade de inserir uma string, um objeto e um boolean no mesmo balaio.

Como criar arrays associativos, mapas dicionários em PHP?

Linguagens como Python ou JavaScript têm o conceito de Dicionário, enquanto Java e C++ possuem seus Mapas. O PHP une todos estes conceitos num formato especial de array: o array associativo.

Um array associativo em PHP é um array parecido com o de índice numérico, com a diferença que nós escolhemos o índice de cada elemento em vez de deixar a linguagem escolher a ordem crescente natural. Além disso, nós podemos também escolher índices que sejam strings em vez de números. Veja:

$ranking_frutas = [
  0 => 'manga',
  5 => 'uva',
  15 => 'maçã',
];

$frutas_fotos = [
  'manga' => '/fotos/manga.jpg',
  'uva' => '/fotos/uva.jpg',
  'maçã' => '/fotos/maca.jpg',
];

Enquanto o primeiro array $ranking_frutas ainda tem índice numérico, sua ordenação não é mais natural: nós forçamos que manga, a melhor fruta do planeta terra, fique em primeiríssimo lugar, e apesar de não saber quem seria o segundo ou terceiro, colocamos maçã, a fruta mais desnecessária que tem, na posição 15.

Já o segundo array é associativo e usa chaves do tipo string. Note que $frutas_fotos não usa números do lado esquerdo, mas sim o nome das frutas. E do lado direito o link para fotos que representam aquela fruta: fruta => foto.

Desta forma podemos acessar os dois arrays usando a mesma sintaxe de colchetes:

echo "A melhor fruta do mundo é: $ranking_frutas[0].";
// A melhor fruta do mundo é: manga

echo "Aqui tem uma foto de manga: $frutas_fotos['manga']."
// Aqui tem uma foto de manga: /fotos/manga.jpg

Portanto as sintaxes $array[0] e $array['string'] são válidas.

Como criar arrays híbridos no PHP?

Você já deve ter calculado que já que é possível criar arrays de índices numéricos e arrays associativos usando a mesma sintaxe, talvez seja possível misturar os dois. E o pensamento é 100% correto.

Em PHP é possível utilizar índices numéricos e de texto numa mesma variável como no exemplo a seguir:

$tudo_junto_e_misturado = [
  0 => 'manga',
  'manga' => 'Melhor fruta, slc!'
];

echo $tudo_junto_e_misturado[0]; // manga
echo $tudo_junto_e_misturado['manga']; // Melhor fruta, slc!

Algumas funções são específicas para arrays de índice numérico, outras para arrays associativos, outras para todos os arrays. Com o tempo e prática você vai entender em quais cenários faz sentido usar um array híbrido. Spoiler: quase nunca faz sentido.

Como criar arrays bidimensionais ou matrizes em PHP?

Como em todas as linguagens em que é possível criar vetores, o princípio da composição nos permite criar vetores de múltiplas dimensões, também conhecidos como matrizes. Na teoria é exatamente o contrário: matrizes podem ter diferentes dimensões, inclusive uma única e neste caso a matriz de única dimensão é chamada de vetor.

Enfim… tudo isso pra te dizer que um array pode conter outros arrays. Por exemplo, podemos representar um tabuleiro de jogo da velha com um array bidimensional assim:

$tabuleiro = [
  ['O', '', 'X'],
  ['O', 'X', ''],
  ['X', 'O', ''],
];

echo "A posição (0, 2) tem o valor $tabuleiro[0][2].";
// A posição (0, 2) tem o valor X.

echo "A posição (2, 1) tem o valor $tabuleiro[2][1].";
// A posição (2, 0) tem o valor O.

E portanto para acessar a primeira “linha” usamos $tabuleiro[0] e a última linha $tabuleiro[2]. Enquanto a primeira célula da primeira linha podemos acessar com $tabuleiro[0][0] e a última célula da primeira linha com $tabuleiro[0][2].

Como adicionar um elemento ao array do PHP?

Em PHP, diferentemente da linguagem C, o array tem tamanho dinâmico. Portanto você pode expandir um array o quanto quiser (e de acordo com a memória RAM disponível em seu ambiente).

Suponha o array $pares com os seguintes números pares: [0, 2, 4, 6]. Vamos ver diferentes formas de adicionar os próximos pares:

Como adicionar um elemento usando a sintaxe de índice?

Já vimos que é possível acessar um valor através de seu índice numérico. Por exemplo $pares[2] nos traria o valor 4. Mas também é possível alterar valores usando esta sintaxe.

Portanto caso queiramos adicionar o próximo par à variável $pares podemos associar seu último índice + 1 com o próximo número. Assim:

// Último índice = 3
$pares[4] = 8;

Neste caso nós sabíamos que o último índice era 3, mas podemos fazer isso de forma dinâmica quando não soubermos quais índices existem no array:

$indice = count($pares); // $indice = 5
$pares[$indice] = 10;

No exemplo acima associamos o valor count($pares) à variável $indice. Nós já tínhamos os valores 0, 2, 4 e 6, e depois adicionamos o valor 8 ao final. Portanto $indice aqui possui o valor 5, que é o número de elementos existentes no array $pares. Depois associamos o valor 10 ao índice $indice (5).

Como adicionar um elemento usando a sintaxe de associativa?

É muito semelhante à forma de trabalhar com índices numéricos, porém utilizamos string como índices. Vamos por exemplo criar um array associativo do tipo matriz para armazenar números pares e ímpares:

$numeros = [
  'pares' => [0, 2, 4, 6],
  'impares' => [1, 3, 5, 7],
];

echo $numeros['pares'][2]; // 4
echo $numeros['impares'][1]; // 3

Perceba que:

• A sintaxe é a mesma: acessamos o elemento pares com a sintaxe de colchetes $numeros['pares'];

• É possível guardar qualquer coisa dentro de um array, inclusive outro array: nós guardamos o array $pares dentro do array $numeros

A sintaxe antiga de arrays do PHP

Em alguns tutoriais e livros mais antigos, você vai encontrar uma sintaxe diferente para trabalhar com array no PHP. Então deixa eu te mostrar como nós costumávamos criar arrays no PHP na idade da pedra da computação:

$meuArray = array(0, 1, 2, 3, 4);

echo "O terceiro elemento é o número $meuArray[2].";
// O terceiro elemento é o número 3.

Esta sintaxe ainda funciona na linguagem PHP, mas está sendo abandonada aos poucos. Portanto utilize colchetes para criar arrays SEMPRE.

Diferentes utilidades do array no PHP

Arrays são praticamente o coração da linguagem PHP. Um dos motivos de o PHP ser tão popular, na minha opinião, é a flexibilidade agregada pelos arrays e como eles se integram a praticamente tudo no ecossistema PHP.

Algumas utilidades do array no PHP incluem, mas não se limitam a:

• Listas
• Dicionários
• Tuplas
• Pilhas e filas

Vamos ver cada um destes itens com exemplos.

Utilizando arrays PHP como listas

Listas são segmentos de valores que podem ou não ser ordenados. Os arrays PHP tornam este trabalho muito simples de se realizar.

Por exemplo, abaixo temos uma lista de frutas completamente desordenada:

$frutas = ['manga', 'banana', 'maçã'];

echo $frutas[0]; // manga
echo $frutas[1]; // banana
echo $frutas[2]; // maçã

Adicionalmente, se quisermos garantir que a lista seja ordenada, podemos aplicar a função sort() para ordenar seus elementos:

$frutas = ['manga', 'banana', 'maçã'];

if (sort($frutas)) {
  echo $frutas[0]; // banana
  echo $frutas[1]; // maçã
  echo $frutas[2]; // manga
}

Utilizando arrays PHP como dicionários

Dicionários são estruturas no formato chave => valor, em PHP são chamados arrays associativos.

Um exemplo de utilização de dicionários é o agrupamento de dados para gerar relatórios. Por exemplo, podemos representar o preço de uma ação em diferentes horários do dia no exemplo a seguir:

$seriePrecos = [
  '10am' => 19.20,
  '3pm' => '21.02',
  '5pm' => '20.59',
];

echo "A ação CODAMOS tinha o preço $seriePrecos['10am'] às 10am de hoje.";
// A ação CODAMOS tinha o preço 19.20 às 10am de hoje.

Eu citei acima o formato chave => valor, para deixar claro o que aquilo significa: no array acima, 10am, 3pm e 5pm são chaves enquanto 19.20, 21.02 e 20.59 são valores.

O maior motivo para utilizarmos dicionários no PHP é adicionar semântica ao nosso código. Esta é uma estrutura de dados muito poderosa e flexível que nos permite representar diferentes conceitos usando o formato chave => valor.

Utilizando arrays PHP como tuplas

Tuplas são dados que estão relacionados e têm pouco ou nenhum significado quando isolados.

Por exemplo, num plano cartesiano as coordenadas são tuplas de dois elementos: x e y. Portanto o valor (x, y) pode ser considerado uma tupla.

De forma semelhante, num espaço de três dimensões, as coordenadas seriam (x, y, z) que também é uma tupla mas de 3 elementos.

Arrays em PHP podem ser utilizados como tuplas naturalmente:

$coordenadas = [10, 20]; // tupla de 2 inteiros
[$x, $y] = $coordenadas; // extraindo valores da tupla

echo "A tupla (x, y) tem valor ($x, $y).";
// A tupla (x, y) tem valor (10, 20).

Utilizando arrays PHP para trabalhar com pilhas e filas

Pilhas são listas em que sempre inserimos valores ao fim do array, e sempre retiramos valores do fim do array. Como uma pilha de pratos: você normalmente coloca o prato no topo da pilha, e tira sempre o prato que está mais ao topo da pilha.

Pilhas sempre utilizam o algoritmo LIFO – Last in, first out. Ou seja: o último elemento que chegou, é o primeiro que vai sair.

Em PHP, os arrays podem ser tratados como pilha ao utilizar as funções array_push() e array_pop():

$pratos = [];
array_push($pratos, 'porcelana');
array_push($pratos, 'plástico');

$pratoDoTopo = array_pop($pratos);
echo "O prato que estava no topo da pilha é feito de $pratoDoTopo.";
// O prato que estava no topo da pilha é feito de plástico.

Exatamente ao contrário do que pilhas fazem, as filas seguem o algoritmo FIFO – First in, first out. Ou seja: quem chega primeiro, sai primeiro! E podemos fazer isso também com a função array_push() para adicionar ao final da fila, e com array_shift() para remover do começo da fila. Para furar a fila podemos também utilizar o array_unshift() que adiciona um elemento logo no começo da fila.

$fila_do_mercado = ['Marcio', 'Maria', 'João'];

$proximo = array_shift($fila_do_mercado);
echo "Vamos atender $proximo agora!";
// Vamos atender Marcio agora!

// Vitória tem preferência na fila
array_unshift($file_do_mercado, 'Vitória');

$proximo = array_shift($fila_do_mercado);
echo "Vamos atender $proximo agora!";
// Vamos atender Vitória agora!

Note que array_unshift() jogou o nome “Vitória” para o começo da fila e portanto este foi o próximo nome a ser chamado.

Como visitar cada elemento de um array no PHP?

Na maioria dos casos nós não queremos acessar apenas um elemento do array, mas sim percorrer o array inteiro para executar alguma ação.

Para arrays de índice numérico, uma saída comum em outras linguagens como o C, é utilizar um laço de repetição como um for ou while juntamente de um contador como no exemplo a seguir:

$frutas = ['manga', 'banana', 'maçã'];

$i = 0;
while ($i < count($frutas)) {
  echo "A fruta do índice $i é $frutas[$i].";
  $i++;
}

// A fruta do índice 0 é manga.
// A fruta do índice 1 é banana.
// A fruta do índice 2 é maçã.

O laço acima, como você provavelmente já entendeu, é equivalente ao laço for a seguir:

$frutas = ['manga', 'banana', 'maçã'];

for ($i = 0; $i < count($frutas); $i++) {
  echo "A fruta do índice $i é $frutas[$i].";
}

// A fruta do índice 0 é manga.
// A fruta do índice 1 é banana.
// A fruta do índice 2 é maçã.

O método acima funciona na maioria dos casos, mas é problemático caso você precise iterar um array do tipo dicionário, em que as chaves não são números ordenados.

O jeito mais fácil de percorrer um array, independente do tipo de índice que tiver, é através da estrutura de iteração foreach. Vejamos o exemplo a seguir:

$frutas = ['manga', 'banana', 'maçã'];

foreach ($frutas as $fruta) {
  echo "Fruta: $fruta";
}

// Fruta: manga
// Fruta: banana
// Fruta: maçã

Note que a variável $i não é necessária para iterar o array. Mas caso você precise desta variável para saber o índice, pode utilizar uma variação do foreach como no exemplo a seguir:

$frutas = ['manga', 'banana', 'maçã'];

foreach ($frutas as $i => $fruta) {
  echo "A fruta do índice $i é $fruta.";
}

// A fruta do índice 0 é manga.
// A fruta do índice 1 é banana.
// A fruta do índice 2 é maçã.

Note que $i no exemplo acima não é um contador, mas sim o índice do array $frutas. De forma semelhante, caso o array possua índices do tipo string em vez de numéricos, a mesma sintaxe vai ser de grande ajuda:

$frutas_favoritas = [
  'nawarian' => 'manga',
  'joana' => 'abacate',
  'pedro' => 'mamão',
];

foreach ($frutas_favoritas as $nome => $fruta) {
  echo "A fruta favorita de $nome é $fruta.";
}

// A fruta favorita de nawarian é manga.
// A fruta favorita de joana é abacate.
// A fruta favorita de pedro é mamão.

Reparou como a porção $nome => $fruta são nomes que eu escolhi? Estas variáveis poderiam ter qualquer outro nome. Não é obrigatório chamar sempre de $key => $value ou $i => $x. Você pode escolher nomes que façam mais sentido na hora de ler o seu código.

💡 Leia também: como escrever código fácil de ler e de dar manutenção.

Como desestruturar arrays no PHP?

Esta sintaxe é relativamente nova e lembra muito o que fazemos no JavaScript!

Como sabemos, dentro do array podemos ter qualquer tipo de dado, mas as vezes estes dados vêm em pares que fazem algum sentido lógico. Se sabemos desta sequência, podemos desestruturar o array e transformar cada elemento em uma variável com um nome que tenha um sentido semântico maior.

Veja o exemplo em que a variável $coordenadas sabidamente tem dois elementos: o primeiro é um valor de x enquanto o segundo elemento é y. Podemos desestruturar este array para obter estes dois valores como variáveis:

$coordenadas = [10, 20];

[$x, $y] = $coordenadas;

Nós já vimos este exemplo enquanto falávamos sobre tuplas. Mas vamos utilizar um exemplo mais interessante: percorrer dados de uma série histórica de valores e imprimir na tela cada data. E aqui nós vamos desestruturar o array dentro do foreach! Veja como funciona:

$serie = [
  ['2022-10-10', 100],
  ['2022-10-11', 115],
  ['2022-10-12', 120],
];

foreach ($serie as [$data, $valor]) { // 👈 olha aqui!
  echo "Em $data o valor era de $valor.";
}

// Em 2022-10-10 o valor era de 100.
// Em 2022-10-11 o valor era de 115.
// Em 2022-10-11 o valor era de 120.

Também é possível ignorar alguns valores simplesmente adicionando uma vírgula , sem nenhum nome de variável. No exemplo a seguir o segundo elemento do array é completamente ignorado:

$frutas = ['manga', 'maçã', 'banana'];

[$manga, , $banana] = $frutas; // maçã nem deveria ser fruta

Isto é bastante útil quando extraímos dados de expressões regulares, por exemplo.

Como extrair elementos do array usando a sintaxe de desempacotamento no PHP?

O desempacotamento de array pode também ser entendido como “expandir” seus elementos, e pra isso a gente usa o operador ellipsis .... Você pode misturar esta sintaxe com diversas outras no PHP como podemos ver a seguir.

$pares = [2, 4, 6];

$pares_com_zero = [0, ...$pares];

Note que o array $pares começa com apenas 3 elementos e que $pares_com_zero é criado com 0 sendo seu primeiro elemento, seguido de todos os outros presentes em $pares. Portanto $pares_com_zero efetivamente tem os valores [0, 2, 4, 6].

Desta forma é possível extrair e combinar diferentes arrays.

Como unir dois ou mais arrays no PHP?

Para unir os elementos de dois ou mais arrays existe três formas:

• A função array_merge()
• A soma de array através do operador +
• Desempacotamento de arrays

Como unir dois arrays utilizando a função array_merge()

A função array_merge() existe justamente pra mesclar (merge) dois arrays em PHP. Você pode passar quantos arrays quiser como argumento, e o retorno será um novo array que une todos os argumentos:

$pares = [0, 2, 4, 6];
$impares = [1, 3, 5, 7];
$numeros = array_merge($pares, $impares);

No exemplo acima o array $numeros combina números pares e impares. Note que os arrays foram apenas unidos, a ordem dos elementos é a mesma que a original.

Para ordenar os números ímpares e pares no array $numeros seria necessário aplicar a função sort().

Como unir dois arrays utilizando o operador +

Uma alternativa sintática ao array_merge() é p operador +, que quando utilizado entre dois arrays realiza a operação de união.

$pares = [0, 2, 4, 6];
$impares = [1, 3, 5, 7];
$numeros = $pares + $impares;

Como unir dois arrays utilizando desempacotamento de arrays

Como vimos antes, é possível obter elementos de um array utilizando a sintaxe de desempacotamento usando o operador ellipsis (...).

Para unir dois arrays utilizando desempacotamento, podemos fazer como no exemplo a seguir:

$pares = [0, 2, 4, 6];
$impares = [1, 3, 5, 7];

$numeros = [...$pares, ...$impares];

Repare que como nos exemplos anteriores, a união dos arrays não é ordenada e portanto a variável $numeros agora possui o valor [0, 2, 4, 6, 1, 3, 5, 7]. Para ordenar os valores, é necessário utilizar a função sort().

Principais funções para trabalhar com array no PHP

Arrays em PHP possuem diversas funções especiais. A documentação oficial da linguagem possui uma lista completa de funções para trabalhar com arrays no PHP.

Vou listar aqui as funções mais comuns e importantes de acordo com a minha experiência.

Função count(): contar elementos de um array

$numeros = [0, 1, 2, 3, 4];
$total = count($numeros);

echo "O array 'numeros' possui $total elementos.";
// O array 'numeros' possui 5 elementos.

Visite a página da documentação oficial para aprender mais sobre a função count().

Função in_array(): indica se elemento existe no array

$numeros = [0, 1, 2, 3, 4];
$existe = in_array(2, $numeros) ? 'existe' : 'não existe';

echo "O número 2 $existe no array 'numeros'.";
// O número 2 existe no array numeros.

Visite a página da documentação oficial para aprender mais sobre a função in_array().

Função sort(): ordena elementos de um array

$numeros = [4, 1, 0, 3, 2];
sort($numeros);

foreach ($numeros as $numero) {
  echo "Número: $numero";
}

// Número: 0
// Número: 1
// Número: 2
// Número: 3
// Número: 4

Visite a página da documentação oficial para aprender mais sobre a função sort().

Função shuffle(): embaralha o array colocando seus elementos em ordem aleatória

$numeros = [0, 1, 2, 3, 4];
shuffle($numeros);

foreach ($numeros as $i => $numero) {
  echo "O número $i é $numero.";
}

// O número 0 é 3
// O número 1 é 0
// O número 2 é 1
// O número 3 é 4
// O número 4 é 2

Visite a página da documentação oficial para aprender mais sobre a função shuffle().

Função array_keys(): obtém apenas chaves (índices) do array, sem valores

$site_pontuacao = [
  'https://codamos.com.br' => 10,
  'https://thephp.website' => 7,
  'https://locaweb.com.br' => 10,
];

$chaves = array_keys($site_pontuacao);
foreach ($chaves as $i => $chave) {
  echo "O site $i é $chave.";
}
// O site 0 é https://codamos.com.br
// O site 1 é https://thephp.website
// O site 2 é https://locaweb.com.br

Visite a página da documentação oficial para aprender mais sobre a função array_keys().

Função array_values(): obtém apenas os valores do array, sem chaves (índices)

$site_pontuacao = [
  'https://codamos.com.br' => 10,
  'https://thephp.website' => 7,
  'https://locaweb.com.br' => 10,
];

$pontuacao = array_values($site_prontuacao);
foreach ($pontuacao as $i => $valor) {
  echo "A pontuação $i é $valor.";
}

// A pontuação 0 é 10
// A pontuação 1 é 7
// A pontuação 2 é 10

Visite a página da documentação oficial para aprender mais sobre a função array_values().

Função array_combine(): une um array de chaves e um array de valores num único array associativo

$sites = [
  'https://codamos.com.br',
  'https://thephp.website',
  'https://locaweb.com.br',
];
$pontuacao = [10, 7, 10];

$site_pontuacao = array_combine($sites, $pontuacao);

foreach ($site_pontuacao as $site => $pontos) {
  echo "O site $site tem $pontos pontos.";
}

// O site https://codamos.com.br tem 10 pontos.
// O site https://thephp.website tem 7 pontos.
// O site https://locaweb.com.br tem 10 pontos.

Visite a página da documentação oficial para aprender mais sobre a função array_combine().

Função array_diff(): indica a diferença entre dois ou mais arrays

$numeros = [0, 1, 2, 3, 4];
$pares = [0, 2, 4];

$diff = array_diff($numeros, $pares);
foreach ($diff as $numero) {
  echo "O número $numero existe no array 'numeros' mas não no array 'pares'.";
}

// O número 1 existe no array 'numeros' mas não no array 'pares'.
// O número 3 existe no array 'numeros' mas não no array 'pares'.

Visite a página da documentação oficial para aprender mais sobre a função array_diff().

Função array_merge(): unindo dois ou mais arrays

$pares = [0, 2];
$mais_pares = [4, 6];
$impares = [1, 3, 5];

$numeros = array_merge($pares, $mais_pares, $impares);
foreach ($numeros as $i => $numero) {
  echo "O número $i é $numero.";
}

// O número 0 é 0
// O número 1 é 2
// O número 2 é 4
// O número 3 é 6
// O número 4 é 1
// O número 4 é 3
// O número 5 é 5

Visite a página da documentação oficial para aprender mais sobre a função array_merge().

Função array_unique(): remove elementos repetidos do array

$numeros = [0, 2, 2, 4, 6, 4];
$numeros_sem_repeticao = array_unique($numeros);

foreach ($numeros as $i => $numero) {
  echo "O número $i é $numero.";
}

// O número 0 é 0
// O número 1 é 2
// O número 2 é 4
// O número 3 é 6

Visite a página da documentação oficial para aprender mais sobre a função array_unique().

Função array_fill(): cria array com tamanho e conteúdo definidos

$quatro_zeros = array_fill(0, 4, 0);

foreach ($quatro_zeros as $i => $valor) {
  echo "O número $i é $valor.";
}

// O número 0 é 0
// O número 1 é 0
// O número 2 é 0
// O número 3 é 0

Visite a página da documentação oficial para aprender mais sobre a função array_fill().

Função array_sum(): soma todos elementos de um array

$numeros = [0, 1, 2, 3, 4];
$soma = array_sum($numeros);

echo "A soma dos 5 primeiros números é $soma.";
// A soma dos 5 primeiros números é 10

Visite a página da documentação oficial para aprender mais sobre a função array_sum().

Função array_map(): aplica uma função a cada elemento do array e retorna um novo array

function dobrar_numero(int $x): int
{
  return $x * 2;
}

$numeros = [0, 1, 2, 3, 4];
$dobro = array_map('dobrar_numero', $numeros);

for ($i = 0; $i < count($numeros); $i++ ) {
  echo "O dobro de $numeros[$i] é $dobro[$i].";
}

// O dobro de 0 é 0
// O dobro de 1 é 2
// O dobro de 2 é 4
// O dobro de 3 é 6
// O dobro de 4 é 8

Visite a página da documentação oficial para aprender mais sobre a função array_map().

Função array_filter(): remove elementos de um array de acordo com um critério

function numero_eh_par(int $x): bool
{
  return $x % 2 == 0;
}

$numeros = [0, 1, 2, 3, 4];
$pares = array_filter($numeros, 'numero_eh_par');

foreach ($pares as $i => $numero) {
  echo "O número par $i é $numero.";
}

// O número par 0 é 0
// O número par 1 é 2
// O número par 2 é 4

Visite a página da documentação oficial para aprender mais sobre a função array_filter().

Como trabalhar com JSON e arrays no PHP?

Podemos transformar arrays de índice numérico ou associativos para transformar uma variável em JSON utilizando a função json_encode(), e podemos também transformar uma string JSON em array utilizando a função json_decode().

$json = '{"site": "https://codamos.com.br", "nota": 10.0}';

$avaliacao = json_decode($json);
echo "O site $avaliacao['site'] é nota $avaliacao['nota']!";
// O site https://codamos.com.br é nota 10.0!

$avaliacao['fonte'] = 'Eu mesmo';
$novo_json = json_encode($avaliacao);
echo $novo_json;
// {"site": "https://codamos.com.br", "nota": 10.0, "fonte": "Eu mesmo"}

Isto é muito útil para trabalhar com APIs rest ou mesmo para ler e escrever configurações em arquivos.

Conclusão

Arrays são um dos principais elementos que tornam a linguagem PHP tão poderosa e este artigo, por maior que pareça ser grande e extensivo, apenas toca na superfície do tópico.

Assim que dominar os tópicos apresentados aqui eu recomendo que você leia mais sobre Iterators e, por conseguinte, classes do tipo Iterator como o ArrayObject, SplStack e classes iteradores especiais da linguagem. A partir daqui você também deverá ter um arcabouço maior para entender como funcionam as Collections do Laravel.

Não esquece de compartilhar este artigo com amigos e colegas de curso ou de trabalho, isto ajuda bastante o blog a crescer e produzir mais conteúdo de qualidade pra quem é dev!

Num futuro próximo eu devo escrever também sobre como arrays se comportam em memória e como otimizar a utilização de memória quando trabalhamos com listas.

Até a próxima 👋

Já faz um bom tempo que venho mentorando pessoas que querem ingressar ou melhorar na área de desenvolvimento de software. E com o tempo comecei a identificar alguns erros e dificuldades comuns que atrapalhavam a vida da pessoa desenvolvedora que está iniciando.

Este guia vai te mostrar os primeiros passos que você deve tomar para aprender a programar para web em 2023. Você precisa começar a entender a mecânica da linguagem (sintaxe) e depois avançar com lógica na prática, através de projetos e cursos.

Entre no nosso grupo de apoio no Telegram

A comunidade Codamos está crescendo e está pronta pra te ajudar em todas as fases da sua jornada com desenvolvimento de software!

Estudar com o apoio de outras pessoas ajuda muito a manter a motivação lá no alto. Principalmente no começo, quando não sabemos nem sequer como fazer a pergunta certa.

Entra no grupo, é de graça e você só tende a crescer!

Comece pelo HTML

A linguagem HTML é uma linguagem de marcação de hipertexto, que serve para criar páginas da internet que você vê através de navegadores como Google Chrome ou Mozilla Firefox. Apesar de não ser considerada uma linguagem de programação, é uma das bases da internet.

Quem quer trabalhar com web precisa saber ao menos o mínimo sobre HTML.

Eu gosto de recomendar iniciantes a aprender HTML porque é uma linguagem relativamente simples mas bastante poderosa. Você vê os resultados de seus estudos imediatamente!

Toda linguagem de programação tem uma série de regrinhas de escrita, chamada sintaxe. Aprender HTML é uma forma incrível de se acostumar com a ideia de sintaxe porque você consegue entender melhor como o computador analisa a sintaxe com uma linguagem simples e com regras bem definidas.

Começar com HTML vai te ajudar a:

• Entender como funciona a sintaxe de uma linguagem;

• Se motivar com resultados imediatos;
• Escrever suas próprias páginas web

Passeie pelo CSS

Com o HTML você é capaz de fazer muita coisa, mas a internet já mudou muito desde que o HTML apareceu e hoje em dia nós temos requisitos de aparência visual de uma página web muito elevados!

Com CSS você consegue alterar a aparência da sua página HTML de forma a mudar as fontes, cores, posição de elementos, deixar algumas coisas fixas no layout e por aí vai.

Eu acho interessante aprender pelo menos o básico de CSS pra entender como a tecnologia funciona, além de te forçar a aprender mais sobre como funciona o seu navegador web.

Alguns sites interessantes para ver mais sobre CSS são o Tableless (em português) e CSS Tricks (em inglês).

Aprender CSS mesmo que superficialmente vai te ajudar a:

• Entender regras de sintaxe de outra linguagem;

• Obter resultados visuais;
• Fazer projetos web completos e funcionais;
• Acompanhar vídeo tutoriais e mini cursos que desenvolvem projetos e clones

Ao conseguir trabalhar, mesmo que só com o básico, de HTML e CSS você já consegue fazer alguns projetos para praticar e montar seu portfolio. Existe centenas de milhares de vídeos na internet de pessoas que fazem projetos passo a passo com HTML e CSS que você pode acompanhar para praticar.

Primeira linguagem de programação: JavaScript

A primeira linguagem de programação que eu recomendo pra quem começa agora em 2023 é o JavaScript.

Isso porque no começo você não sabe bem o que quer fazer: back end, front end, DevOps… e o JavaScript vai te acompanhar em quase todas as áreas.

Eu particularmente não gosto de JavaScript, prefiro ensinar com PHP que é muito mais simples e fácil de aprender na minha opinião. Mas em termos de utilidade o JavaScript vai te acompanhar por mais tempo.

Quando aprender JavaScript eu recomendo separar seu estudo em duas partes: sintaxe (como escrever código) e lógica (como fazer um código útil).

Estudar lógica é um pouco mais complicado: você precisa praticar bastante. Então é melhor praticar de um jeito que você goste pra não perder a motivação!

Você pode fazer exercícios de programação em JavaScript em sites como o HackerRank. Mas eu recomendo imensamente fazer projetos acompanhando vídeos. No YouTube você encontra diferentes guias de como escrever jogos, clones de sites conhecidos como Twitter ou Netflix.

Um exemplo incrível desses projetinhos em vídeo é a Pokédex do Manual do Dev, se liga:

Familiarize-se com a linha de comando

Trabalhar com linha de comando não é obrigatório, mas vai te ajudar MUITO a entender como o computador funciona. A minha intenção em te falar pra aprender a usar a linha de comando não está nem relacionada com aprender algo novo, mas sim de fazer imersão!

Se você usa o Windows, pode começar com o Windows Power Shell. Esta é a ferramenta padrão do Windows e te dá uma flexibilidade incrível na hora de trabalhar. Aqui tem um vídeo de como abrir o terminal e com alguns comandos básicos pra você começar no Windows.

Pra quem usa Linux ou MacOS, o próprio sistema te oferece um terminal que te dá acesso a fazer tudo o que quiser e mais um pouco! E o legal destes desses dois sistemas é que normalmente o mesmo comando funciona tanto no Linux quanto no MacOS.

Aqui um vídeo de como abrir o terminal no Linux (Ubuntu) e alguns comandos básicos.

Aprenda o básico sobre git e github

GIT é uma ferramenta incrível pra armazenar e controlar seus arquivos. E o GitHub te permite fazer isso de graça online, sem limites. Pra além disso você consegue usar o GitHub como uma plataforma pra exibir seu portfólio e também pra contribuir com outros projetos!

Aprender GIT vai te dar uma ajuda muito boa em procurar e navegar projetos escritos por outras pessoas.

Mas não precisa fazer um mega curso e ficar especialista no assunto. O básico já é suficiente pros seus primeiros anos na carreira.

Aqui no blog a gente tem um artigo muito legal e detalhado pra te ajudar a começar com GIT. Dá uma lida no artigo e aproveita pra ver o vídeo de apoio que tem lá. Vai te ensinar tudo o que você precisa de começo.

Faça uma aplicação clone

Nessa altura do campeonato você já aprendeu HTML, CSS, JS e GIT. Está mais do que na hora de fazer alguns projetos que possam te servir de portfólio pra subir no Github!

Aplicações clone são uma forma incrível de montar seu portfólio, porque você não precisa se preocupar com conceitos, design, requisitos… você só precisa copiar o que já existe!

Alguns cursos e vídeos online te mostram como fazer clones do Twitter, do Netflix, do site de alguma marca…

Eu encontrei, por exemplo, este vídeo incrível da Lari que mostra como ela montou um clone da tela de login do Netflix. Dá uma olhadinha:

A parte bacana de fazer um curso de criar aplicação clone é que, se em algum momento você travar, ainda pode copiar diretamente do vídeo e continuar aprendendo outras coisas.

Revise sua aplicação clone

Eu já escrevi aqui sobre erros comuns que iniciantes cometem, que dificultam o aprendizado e até atrasam quem tá começando agora. E uma das técnicas pra evitar estes erros é a refatoração.

O simples exercício de você revisar e melhorar um código que você já escreveu vai te ajudar a entender melhor o que seu código faz e o que você ainda precisa estudar melhor.

Muitas vezes quem é iniciante e escreve uma aplicação clone com apoio de vídeo aulas não consegue entender 100% do código que escreveu. Por isso o exercício de revisão e melhoramento do código é essencial.

Dê uma pausa e reflita sobre onde você está

Se você tiver concluído cada um dos passos que eu mencionei aqui, provavelmente estará bem mais confortável com o tópico programação e já tem dúvidas o suficiente pra saber o que perguntar e por onde ir.

Um ponto importante é não se afobar e tentar dar passos maiores que a perna, pra evitar perda de tempo, de energia e até mesmo se frustrar no processo.

O Leonardo Leitão da Cod3r Cursos fez um vídeo sensacional que explica as diferentes fases na vida de uma pessoa que resolve aprender a fazer desenvolvimento de software e como se portar em cada fase. Vídeo recomendadíssimo!

Conclusão

A partir daqui você já sabe tudo o que precisa para estudar programação sem muito sofrimento: toda a mecânica de lidar com sintaxe de linguagem, alterar código, analisar resultados e melhorar o que fez deverá estar mais ou menos clara.

Se você concluiu cada passo, já deve ter proficiência o suficiente pra estudar algoritmos e aprender outros conceitos como o de utilizar bancos de dados ou criar APIs.

Desenvolvimento de software é uma profissão na qual você nunca para de estudar. Continue buscando artigos na internet, escute podcasts, leia livros, participe de conferências… enfim! Você já tem tudo o que precisa pra estudar programação.

Boa sorte em sua jornada!

A comunidade PHP é maravilhosa porque consegue unir muita gente entusiasmada em torno deste projeto, um dos poucos verdadeiramente Open Source e conduzidos pela comunidade de forma orgânica!

Esta forma orgânica de a comunidade se organizar apesar de bonita, não é infalível: nós sempre precisamos de mais e mais pessoas contribuindo para que a máquina continue girando. Neste artigo você vai conhecer um pouco mais sobre como contribuir com a linguagem através de traduções.

Para contribuir com traduções do PHP você precisa ter uma conta no Github e acessar o projeto php/doc-pt_BR. Neste artigo eu te explico tintim por tintim, num passo a passo como proceder para traduzir o manual da linguagem!

Passo a passo de como contribuir com a documentação do PHP

Passo 1 – Crie uma conta no Github

Você possivelmente já tem um perfil no Github, mas não custa nada deixar aqui um guia para quem ainda não tem ou não sabe alterar arquivos no Github.

Nós temos um artigo incrível sobre como começar com e subir arquivos no Github, bem explicadinho que é pra não ter erro!

Passo 2 – Faça uma cópia do projeto php/doc-pt_BR

Com sua conta criada, é possível fazer uma cópia do repositório php/doc-pt_BR para sua conta pessoal. Desta forma você tem liberdade total para alterar os arquivos a forma como quiser e mais tarde poderá solicitar que suas mudanças sejam integradas à documentação oficial.

Na tela do Github, basta clicar no botão Fork e seguir as instruções:

Após fazer a cópia (Fork) do projeto, você deverá ter um repositório idêntico em seu perfil do Github. O meu ficou assim:

Passo 3 – Escolha com qual arquivo quer trabalhar

Caso você não queira procurar arquivos desatualizados ou mesmo não traduzidos e queira apenas achar uma forma rápida de contribuir, você pode verificar as Issues abertas do projeto. Você provavelmente encontrará alguém que já está coordenando a tradução de uma parte do manual.

Hoje, por exemplo, eu encontrei a Issue #150 que atualiza o arquivo language/namespaces.xml, referente à página do manual Namespaces. Este arquivo possui várias seções e o autor @alfsb está coordenando a tradução de cada uma das partes.

Antes de começar a traduzir um arquivo ou parte dele, avise a comunidade através de issues como esta para evitar retrabalho e conflitos.

Note que, como o arquivo está separadinho em diversas seções, pessoas diferentes podem verificar o que está faltando e contribuir mesmo que com um pequeno pedacinho da documentação!

Outra opção é encontrar arquivos desatualizados utilizando a ferramenta revcheck que a própria comunidade disponibiliza online.

Passo 4 – Se familiarize com a estrutura do documento

A documentação do PHP foi redigida utilizando a linguagem xml no formato DocBook.

Ao navegar pelos arquivos você provavelmente vai entender o que cada elemento faz. Mas abaixo eu deixo uma tabelinha que talvez lhe ajude:

Passo 5 – Altere o arquivo em sua cópia

Aqui você pode optar por clonar a cópia do repositório (Fork) em sua máquina local, como descrito em nosso artigo de como subir arquivos para o Github.

Outra opção é fazer a edição diretamente pela interface gráfica do Github. Foi o que eu fiz quando ajudava a traduzir a Issue #150 que traduz o arquivo language/namespaces.xml. Para isto, na minha cópia (Fork) do repositório eu encontrei o arquivo language/namespaces.xml e abri o editor de texto como na imagem abaixo:

Passo 6 – Faça um commit de suas alterações

Ao finalizar suas alterações completa ou parcialmente, você pode salvar seu progresso ao realizar um Commit de seus arquivos.

Pela interface do Github, logo abaixo do editor de código, encontraremos uma caixa de texto com o título Commit changes. A primeira caixa de texto é o título do commit e a caixa logo abaixo te permite oferecer uma descrição mais detalhada.

Não se preocupe! Como você está operando com uma cópia do projeto (Fork), ninguém vai receber suas alterações até que você faça um Pull Request, que é o último passo da nossa missão. Vamos à ele!

Passo 7 – Abra um Pull Request

Agora que você já possui as atualizações que gostaria de lançar à documentação oficial, é hora de solicitar que outras pessoas da comunidade revisem seu texto e aprovem ou solicitem modificações. Para isto nós precisamos abrir um Pull Request.

Em sua cópia do repositório (Fork), clique na aba Pull Requests e clique no botão New pull request:

Ao apertar o botão New pull request, assumindo que você fez o commit de suas alterações como descrito no passo anterior, uma tela parecida com a seguinte deverá aparecer:

Se estiver tudo certo em sua opinião basta abrir o Pull Request e aguardar a comunidade revisar. Daqui pra frente, você vai interagir com outras pessoas da comunidade que vão lhe indicar quais alterações realizar ou simplesmente aceitar suas contribuições de bom grado!

O pull request que estou usando como exemplo aqui é o de número #188, disponível aqui.

Modalidades de contribuição com a documentação

O projeto php/doc-pt_br te permite contribuir de duas formas fundamentais: atualizando documentos já desatualizados ou traduzir documentos ainda sem tradução. A prioridade é sempre de documentos desatualizados.

Para além disso, você pode monitorar o repositório para ajudar a revisar issues e pull requests, de forma a permitir que outras pessoas tenham suas alterações aceitas mais cedo.

Mais detalhes você encontra na página Situação atual da Wiki do php/doc-pt_br, que descreve exatamente como encontrar estes arquivos e o que fazer.

Motivos para contribuir com a documentação do PHP

Se fazer parte de um projeto grandioso como o PHP não é motivo o suficiente, eu separei alguns motivos que podem te convencer a contribuir, ou talvez convidar mais pessoas a contribuir com o projeto:

Primeiro motivo: devolver à comunidade. O PHP já ajudou milhares de pessoas a mudar de vida direta ou indiretamente. E, na minha opinião, foi um dos maiores motores para o crescimento do que hoje nós conhecemos como Internet. É um projeto que nasceu e cresceu totalmente aberto e gratuito, contribuir com sua tradução é uma forma de retribuir ao esforço empreendido pela comunidade.

Segundo motivo: destacar seu currículo. Eu ouço de diversas pessoas que estão iniciando agora em programação sobre como fazer com que seu currículo ganhe destaque frente a tantas outras pessoas que se candidatam a mesma vaga. Contribuir com projetos abertos é uma forma incrível de ganhar destaque, ainda mais um projeto complexo como o PHP.

Terceiro motivo: aprender mais e mais detalhes sobre a linguagem PHP. Ao traduzir a documentação você se força a ler, interpretar e entender o conteúdo daquele documento. É uma forma muito boa de solidificar seu conhecimento sobre a linguagem e também de descobrir funcionalidades novas que você talvez não conhecesse antes.

Quarto motivo: treinar para a certificação. A certificação PHP da Zend é a única certificação PHP reconhecida no mundo do trabalho hoje em dia, e te exige profundo conhecimento da linguagem. Traduzir a documentação com certeza te ajuda a revisar material e solidificar conhecimento.

Quinto motivo: praticar o inglês. A documentação original é escrita em inglês, língua essencial para pessoas que trabalham com desenvolvimento de software há muito tempo. Ao traduzir a documentação para o Português, você se força a exercitar seu inglês na forma de leitura, gramática e interpretação de texto com um tópico que você provavelmente já possui familiaridade.

Sexto motivo: participar do Hacktoberfest. O hacktoberfest acontece todo mês de Outubro e é organizado pela DigitalOcean. A ideia é influenciar mais pessoas a contribuírem com projetos de código aberto e, como recompensa, a DigitalOcean e empresas parceiras enviam brindes a quem contribui.

Gostaria de adicionar algum motivo aqui? Me dá um toque lá no Twitter: @nawarian.

O impacto causado ao traduzir o manual do PHP para a língua portuguesa

Cerca de 290 milhões de pessoas no mundo inteiro já falam ou falarão Português em breve! De acordo com a Wikipedia, os 10 países a seguir têm Português como sua língua oficial:

• Brasil
• Angola
• Moçambique
• Portugal
• Guiné-Bissau
• Timor-Leste
• Guiné Equatorial
• Macau
• Cabo Verde
• São Tomé e Príncipe

Ao traduzir o manual da linguagem PHP para a língua portuguesa, você cria impacto direto a todos os países acima citados e ainda ajuda pessoas de outros países que queiram praticar e aperfeiçoar seu domínio da língua portuguesa.

Sem contar com nossos hermanos que por muitas vezes não encontram documentação em espanhol e optam por adivinhar o que está escrito em português.

Conclusão

Fica claro que para contribuir com a linguagem PHP você não precisa saber nada sobre a linguagem C. Um pouco de tempo livre, boa vontade e um dicionário já são suficientes pra te colocar em posição de ajudar a comunidade a crescer.

Além disso o impacto causado por uma pequena tradução para o português é multiplicado por 10, visto que tantos países adotam a língua portuguesa como língua oficial. E tantos outros têm a opção de arriscar um portunhol.

Por fim, participar da comunidade e contribuir com projetos Open Source é uma forma sensacional de tornar-se uma profissional melhor, tanto como pessoa quanto tecnicamente.

Fala galera, tudo belezinha? Novamente pokemaobr aqui para falar com vocês sobre coisas de desenvolvimento. Dessa vez iremos falar um pouco sobre as etapas que você irá passar após conseguir o seu emprego como dev.

Realmente é uma parte muito complexa o início dos estudos em desenvolvimento, até a conquista do seu primeiro emprego. Porém, os esforços não acabam por aí. Existem algumas coisas a se fazer assim que entramos na empresa e algumas coisas que devemos saber antes de começar nossa caminhada dentro do desenvolvimento propriamente dito.

A primeira palavra que acho que devo dizer com um conselho para você que conseguiu um emprego é: CALMA. Nada do que você pensou vai ser imediato e é importante você ter essa idéia antes do seu primeiro dia.

Em geral você não vai ter acesso a nenhum código nos primeiros dias, vai passar alguma parte do seu dia em reuniões que talvez não façam muito sentido para você, irá tirar parte do tempo que você pensou que iria só estar codando para ler documentações, conhecerá por alto as áreas de atuação da empresa, conhecerá a equipe que trabalhará com você e provavelmente outras equipes que trabalharão indiretamente com você.

Caso você opte pelo regime de trabalho CLT (no Brasil), a primeira coisa a se fazer antes de começar o trabalho em si é assinar os contratos, a galera pega também a sua carteira de trabalho e te pedem para fazer o exame médico de admissão, nesse exame basicamente uma pessoa médica te perguntará algumas coisas acerca da sua saúde, te pesará e medirá sua altura, e observará você para entender se está com aptidão ao trabalho ao qual te designaram.

Já no regime PJ, você deverá abrir uma empresa e aguardar o período da abertura para poder emitir nota. (É interessante você contratar e conversar com uma pessoa contadora antes para entender o processo geral em que se encaixa a atividade de desenvolvimento de software no simples nacional). Eu particularmente não indico o regime PJ para quem está no primeiro emprego de desenvolvimento, mas, por exemplo, minha primeira experiência após sair da faculdade foi nesse regime, então é bem importante você ler sobre isso antes de entrar.

Após resolvidas essas burocracias, vamos ao que interessa. O que geralmente vai ocorrer com você quando iniciar o trabalho?

Suas Boas Vindas

Hoje em dia, até mesmo por influência do LinkedIn, muitas empresas oferecem o que chamamos de welcome kit (kit de boas vindas) para quem está entrando. Esse kit é meio que um modo de mostrar que a empresa se preocupa com você, é muito comum você receber quando entra em uma grande empresa, em uma startup “popzinha” ou agora no regime remoto.

Varia demais de empresa para empresa o que você receberá neste kit, em algumas até notebook e cadeira gamer você recebe, em outras alguns snacks, adesivos, camisetas e adivinhem??? cadernos rs.

Hoje em dia eu acho legal quando você recebe coisas massas no welcome kit, você já começa a sua jornada na empresa de um modo que te anima e em geral espera coisas boas nos dias que sucedem o começo. Porém, não ter welcome kit ou não ter algo que brilhe seus olhos, não faz da empresa um lugar ruim.

O onboarding

O processo de inicialização (primeiros dias da sua entrada em uma empresa) é chamado de onboarding. A ideia desse processo é que você se sinta parte dos processos na empresa, conheça um pouco da sua equipe e das equipes que você trabalhará diretamente, entenda o ciclo de desenvolvimento que será aplicado e, pouco a pouco, comece a receber suas demandas.

Aqui que muita gente acaba se desesperando quando começa um emprego dev. Na maioria das empresas, você vai demorar um tempo até mexer no código de verdade e a ansiedade da galera que está começando aflora demais nesse período.

É importante entender que grande parte das empresas trabalha com algum nível de criticidade em seu negócio e também com algum tipo de confidencialidade, e é importante você estar a par do que você vai poder ou não fazer. Além de entender o básico sobre como funciona o processo de desenvolvimento dentro da empresa em si.

Então, se você não tem muita experiência na tecnologia, nesse período sua equipe vai te convidar para estudar mais e se aprimorar. Além disso, você vai ter suporte da equipe para entender o processo de versionamento de código, entender superficialmente sobre a stack que é utilizada, entender o estilo de código que é desenvolvido, como é organizado o código, as principais regras de negócio que você vai ter que lidar e outras peculiaridades.

Outra coisa importante a se observar e que antes da gente entrar na área de desenvolvimento a gente acaba não entendendo, é que o onboarding sempre é algo demorado, independente do nível de senioridade. Ouso até ao falar que quanto mais sênior, mais demorado o onboarding.

Minha dica: perturbe realmente as pessoas que já estão lá a mais tempo! É importante no começo da sua carreira como dev (na verdade não só no começo), você absorver o máximo de conhecimento que puder, até para facilitar quando você começar a mexer nas coisas realmente.

O trabalho propriamente dito

Após apresentadas todas as premissas para você poder começar a trabalhar realmente, aí sim você vai colocar a mão na massa e começar a desenvolver as coisas. Cada empresa tem sua maneira de gerenciar as tarefas e o modo que vai ser entregue. Mas, um fluxo normal de trabalho que é bem aplicado hoje em dia é o SCRUM (um framework agile), ou algo parecido com isso.

O que quer dizer que geralmente a cada 2 semanas (depende da empresa/equipe), haverá uma reunião para definir as tarefas de cada pessoa e você terá um prazo estipulado entre essas 2 semanas para realizar o desenvolvimento delas. E haverão outras reuniões (geralmente uma reunião diária e outras complementares) para entender o andamento das tarefas e o que te impede de realizá-las caso tenha algum problema.

Nessa fase também, você irá realmente entender na prática como funciona o sistema de versionamento utilizado na empresa, os padrões de código e arquiteturas, os processos de deploy, entre outras fases do desenvolvimento.

Com o passar do tempo você vai pegar o jeito da empresa trabalhar e ficará bem mais fácil fazer realmente parte do todo.

Veja também: como evitar programação por coincidência e sempre ter certeza de que seu código está livre de erros.

Seu crescimento e de olho em novas oportunidades

É sempre importante você continuar atuante também fora da empresa para se manter em atualização: seja participando de comunidades de desenvolvimento, consumindo conteúdo de criadores, fazendo cursos, participando de eventos, alimentando seu github com projetos pessoais ou auxiliando em projetos open-source, etc.

Uma premissa que é bem verdadeira, ainda mais na área de desenvolvimento. As pessoas recrutadoras buscam muito mais pessoas que já estão empregadas que as pessoas que não estão. E, se atualizando constantemente, você será uma pessoa muito bem vista. 

Descreva bem suas habilidades no LinkedIn, se possível tenha um site portfólio. Palestre, se divulgue, tenha um twitter ativo, dentre essas coisas que você lê, escuta e/ou assiste por aí. 

A área de desenvolvimento está muito aquecida, mas, você não pode parar no tempo. Evolua sempre, se atualize sempre, estude sempre, e se mostre relevante. Quando você fizer isso, não precisará mais correr atrás de vagas. As vagas virão até você.

Desejo que tenha curtido o conteúdo e que ele te ajude a ter uma ideia de como será o seu início na área de desenvolvimento

Caso tenha alguma dúvida pode entrar em contato comigo no [email protected] ou na minha live: https://twitch.tv/pokemaobr ou no twitter: https://twitter.com/pokemaobr!

Obrigado de coração e até a próxima.

Recentemente o Codamos recebeu um artigo do Rouan Wilsenach sobre o conceito de Ship / Show / Ask, que basicamente diz que não faz muito sentido esperar seu time aprovar um Pull Request pra integrar o seu código na maior parte das vezes.

A intenção é boa, mas muitas de nós ainda fica com um pé atrás: como garantir a qualidade do software se o Code Review acontece depois de lançar pra produção?

Neste artigo eu vou te apresentar uma técnica mágica que vai mudar para sempre a forma como você lida com código nas suas empresas: as feature flags!

O que é feature flag ou feature toggle?

Feature flag, também conhecida por feature toggle, é uma técnica que lhe permite proteger parte do seu código de forma dinâmica. É como se você pudesse colocar um interruptor no seu código, e só quando você virar a chave o novo código passa a valer.

Na prática a feature flag te permite adicionar alguns IFs no seu código, que vão executar uma ou outra lógica dependendo do estado desta feature flag. Dá uma olhada no exemplo abaixo 👇!

Exemplo de código

Digamos que o método Users.list() atualmente chama uma API rest no endpoint /v1/users e o mantenedor desta API disse que a versão 2 está disponível através do endpoint /v2/users e precisa ser adotada, ao final do mês a versão 1 será descontinuada.

A migração parece bem simples e direta. Mas é sempre bom manter-se longe de problemas. Uma forma simples e livre de muitas preocupações para implementar esta mudança é através de uma feature flag. Olha o exemplo abaixo:

class Users:
  def list(self):
    if (isFeatureActive('enableUserListV2API'):
      return self.listV2()
    else:
      return self.listV1()

  def listV1():
    """
    Call /v1/users
    """

  def listV2():
    """
    Call /v2/users
    """

A função isFeatureActive() retorna TRUE or FALSE, e o ideal é que possamos configurar o retorno desta função. Talvez escrevendo num banco de dados, talvez escrevendo num arquivo...

Acho que deu pra entender bem a ideia de feature flag já. Vou deixar um vídeo (em inglês) abaixo que explica com palavras e imagens como feature flags funcionam caso esteja interessade em se aprofundar no assunto.

O interessante sobre este vídeo é exatamente a ideia de fazer deploy de forma intencional. A filosofia por trás disso é basicamente a mesma que eu mostrei no meu artigo sobre programação por coincidência X por intenção.

Que problemas feature flags resolvem?

De acordo com Pete Hodgson, num artigo que publicou no blog do Martin Fowler, as feature flags resolvem diferentes categorias de problemas:

Proteger lançamentos de produtos

As vezes a pessoa que faz a gerência de produto gostaria de testar o produto em produção algumas semanas ou dias antes de realizar o lançamento oficial. E o ideal seria poder lançar o produto sem que uma pessoa desenvolvedora esteja envolvida.

De forma que uma feature flag é a opção perfeita para resolver o caso acima. A pessoa desenvolvedora pode criar uma flag chamada habilitarNovoCheckout, por exemplo, e utilizá-la em todo o código novo. A pessoa que gerencia o produto pode a qualquer momento ativar ou desativar o novo checkout apenas apertando um botão liga/desliga numa interface.

Algo assim:

<CheckoutFlow>
  {
    isFeatureActive('habilitarNovoCheckout') ? (
      <NovoCheckoutFlow {...props} />
    ) : (
      <AntigoCheckoutFlow {...props} />
    )
  }
</CheckoutFlow>

Realizar experimentos e testes

O bacana de feature flags é que elas não precisam levar em consideração apenas o estado ligado/desligado. A decisão sobre uma feature flag estar ativa ou não pode ser bem mais complexa e levar em consideração elementos como:

• Distribuição de tráfego
• ID / Sessão do usuário
• Localidade do usuário
• Data / Horário
• etc..

De forma que você pode configurar uma flag para estar ativa somente para usuários da cidade de São Paulo acessando o site aos finais de semana entre 10am e 3pm. Tudo depende da ferramenta que você utilizar para feature flags, mas acho que dá pra entender o potencial.

Proteger-se de catástrofes

Por mais que nós escrevamos código utilizando TDD, que façamos revisão de código com nossos pares, e adotemos um processo rígido de qualidade de software, nada garante que o nosso código não vá causar algum tipo de anomalia.

Uma funcionalidade talvez acabe sendo tão popular que muito mais pessoas do que o esperado a querem utilizar, aumento a carga no servidor. Ou talvez você tenha reparado que um algoritmo não está fazendo exatamente o que deveria.

Ao notar um problema desta dimensão, você pode facilmente desligar uma feature flag e investigar a solução de forma controlada. Sem precisar reverter algum deployment ou, pior ainda, um commit.

Gerenciamento de permissões

Algumas funcionalidades precisam ficar protegidas. E os sistemas de ACL nem sempre são suficientes.

Por exemplo, digamos que a área de gerenciamento da sua plataforma precise ser acessada somente por computadores dentro da VPN da empresa. Uma feature flag que verifica a origem do IP pode facilmente resolver esta verificação sem nenhuma adição ao seu framework de ACL.

Que problemas feature flags criam?

Como você já deve ter imaginado, feature flags adicionam complexidade ao seu código. Ainda mais considerando que você pretende testar seus códigos, certo?

A complexidade dos testes é maior

Vejamos o snippet abaixo:

function sumPositive(int|float a, int|float b): int|float
{
  if (typeof(a) !== typeof(b):
    raise "Cannot add an integer to a float"
  return a + b
}

Eu esperaria ver ao menos três testes para esta função, de forma a cobrir os seguintes casos:

• Soma de dois inteiros
• Soma de dois floats
• Lançamento de exceção

Se nós adicionar uma feature flag que nos impede de somar números negativos, o código rapidamente se transformaria em algo assim:

function sumPositive(int|float a, int|float b): int|float
{
  if (typeof(a) !== typeof(b):
    raise "Cannot add an integer to a float"

  # New code
  if (isFeatureActive('disableNegativesSum') && (a < 0 || b < 0)):
    raise "Summing negative numbers is not allowed"

  return a + b
}

Ao adicionar uma feature flag nós precisamos agora adicionar dois outros testes:

• O comportamento quando a feature flag está inativa
• O comportamento quando a feature flag está ativa

Depurar e reproduzir situações descritas em logs

A complexidade se reflete não somente nos testes, mas também ao depurar uma determinada chamada de método ou página.

Além disso, olhando apenas para os logs de acesso não é tão simples identificar se uma determinada flag estava ativa no momento ou não.

Com o tempo, é ideal remover as feature flags que já não têm mais nenhuma utilidade. A cada vez que você cria uma feature flag nova, você está também criando um novo caminho em seu software que precisará ser limpo depois.

Gerenciamento e governança de software

O mau gerenciamento de feature flags pode explodir seu software em complexidade e dificultar a manutenção deste ao longo do tempo se a sua equipe não limpar estas flags frequentemente.

Portanto ao criar uma feature flag nova é ideal sempre ter em mente quando e como você pretende se livrar desta flag.

Aqui onde eu trabalho, uma das técnicas que a gente adota pra limpar feature flags é gerar um dashboard que mostra todas as flags ativas por data e com a possibilidade de marcar cada flag como "pronta para ser removida". Com base neste dashboard a gente consegue escrever tarefas para fazer esta limpeza.

Como eu integro feature flags no meu software?

Algumas empresas – onde eu trabalho, por exemplo – preferem criar o próprio software de gerenciamento de feature flags. Outras adotam soluções de mercado já prontas, e outras ainda preferem utilizar plataformas de código aberto.

As três formas de implementação são validas e você precisa entender bem qual o caso de uso que você precisa cobrir.

Migrar de uma solução para outra é relativamente simples, dado que o código normalmente vai chamar uma função ou método chamado isFeatureActive() ou alguma coisa assim.

O único desafio numa migração é justamente mover os dados de uma solução para outra e manter os SDKs compatíveis.

Pacotes pagos

O bacana de usar uma solução paga é que normalmente tudo já funciona sem precisar configurar muita coisa, e normalmente as empresas oferecem suporte.

O que eu acho particularmente zoado é que no evento de um ataque à plataforma paga, o seu software pode ficar parcialmente disponível ou, pior ainda, ter o comportamento aleatoriamente bagunçado.

Plataformas conhecidas de gerenciamento de feature flags incluem LaunchDarkly™ e Optimizely.

Pacotes open source

Pacotes de código aberto são uma ótima opção porque normalmente exigem pouca configuração/preparo. Mas adiciona complexidade à sua infraestrutura que precisa de constante manutenção.

Dentre os pacotes mais conhecidos estão o Unleash e Flipper.

Implementação própria

A implementação própria normalmente parece a melhor opção durante os primeiros meses/anos. O motivo é que no começo você provavelmente vai identificar vários casos de uso complexos que são muito específicos do domínio da aplicação.

Com o tempo, o número de alterações no software de gerenciamento de flags vai diminuir até o ponto em que este pedaço de software entra em modo de manutenção.

Neste momento eu acho que faz muito mais sentido procurar uma solução paga ou de código aberto, para substituir a implementação própria.

O problema de uma implementação própria é que a partir do momento que ela não dá mais problemas, dificilmente a empresa irá revisitar a implementação, corrigir bugs ou identificar problemas de segurança.

Um serviço pago ou de código aberto te fornece atualizações constantes e melhorias no software.

Conclusão

Feature flag é uma técnica incrível para proteger seu código de diferentes formas: lançamento de produtos independente do envolvimento de pessoas desenvolvedoras, proteger e recuperar de catástrofes e remover completamente a necessidade de Pull Requests antes de lançar o código para produção usando o processo Ship / Show / Ask.

Utilizar feature flags aumenta a sua flexibilidade, mas vem com um custo alto de manutenção.

Por fim, este é um dos passos essenciais para a tão sonhada Integração e Entrega Contínua (CI/CD). Sem um bom monitoramento e ferramentas para forçar curto-circuitos (como feature flags lhe permitem), CI/CD pode ser extremamente perigoso.

Eu li este livro pela primeira vez há alguns anos, e esta já é minha terceira leitura do mesmo título. Eu recomendo DEMAIS ler este livro e tirar suas próprias conclusões, citações e o que mais for.

Este artigo vai com certeza enviesar a forma como você vai ler o livro Refactoring, mas o conteúdo e qualidade do livro não mudam. E caso você tenha dificuldade com leituras longas, com certeza vai ser útil pra ti ler este artigo primeiro.

Esta é uma literatura fundamental para toda pessoa que trabalha com desenvolvimento de software. Eu desconfiaria de qualquer dev sênior que nunca tenha ouvido falar do termo Refactoring (refatoração).

Revisão e ideias centrais

A estrutura do livro

O livro possui duas partes: a primeira apresenta a teoria de refatoração e alguns exemplos práticos enquanto a segunda parte é só um catálogo de refatorações.

Dentre os exemplos Martin Fowler mostra alguns códigos – a última edição vem com códigos em JavaScript, bem feios por sinal – e explica, passo a passo, como torná-los mais legíveis e mais fáceis de testar.

O catálogo de refatoração mostra não só o motivo daquela refatoração, mas também dá um nome à elas. Isto é poderozíssimo porque cria um vocabulário comum entre pessoas desenvolvedoras. Da mesma forma que você entende facilmente o que é uma classe do tipo Factory, o livro busca criar compreensão sobre o que significa a refatoração Extrair Método.

Ler os exemplos do livro é uma experiência mágica porque o autor não apenas explica o que está acontecendo linha a linha, mas também faz referência aos nomes das refatorações que utilizou de seu próprio catálogo.

Neste artigo eu não vou focar no catálogo em si, mas sim na parte teórica. Se você tem curiosidade sobre o catálogo, dê uma olhada na apresentação da incrível Jucy Cabrera (@jucycabrera) fez ano passado no Locaweb PHP Community Summit.

A apresentação da Jucy começa no minuto 02:03:00

O que é refatoração?

Refatoração, de acordo com Martin Fowler, é o ato de alterar um código sem mudar o seu comportamento observável.

Por exemplo, a função a seguir recebe dois parâmetros e retorna um inteiro, contendo a soma destes dois parâmetros:

function sum(int a, int b): int
{
  for (; a < b; a++) return a
}

Não há nada de errado com este código, exceto pelo fato de fazer pouco sentido fazer uma soma desta forma. Mas de toda forma, se chamarmos a função desta forma sum(10, 10) receberemos o valor 20, e se chamarmos assim sum(20, 30) receberemos o valor 50.

Alterar o código da função acima de forma que ao receber os mesmos parâmetros ela retornará os mesmos valores é uma refatoração. Vejamos:

function sum(int a, int b): int
{
  return a + b
}

Porém alterar a assinatura da função, por exemplo, não é uma refatoração. Ou adicionar lógicas à ela. O seguinte snippet não pode ser considerado refatoração, porque muda a assinatura da função:

function sum(int a, int b): float
{
  if (a < 0 || b < 0) throw 'Dont be so negative'
  return parseFloat(a + b)
}

Ao alterar a função acima desta forma nós deixamos de somente refatorar o código e passamos a reescrevê-lo por conta de três alterações principais:

1. O tipo de retorno mudou de int para float;
2. Adicionamos uma lógica que lança exceção;
3. Utilizamos a função parseFloat() que pode alterar fundamentalmente o valor esperado

Note também que "refatoração" depende muito do nível de abstração a partir do qual observamos. Uma reescrita a nível de função pode ser uma refatoração a nível de módulo.

Um ponto importantíssimo citado no livro fala sobre as oportunidades de corrigir um erro ou mal funcionamento do software. Corrigir um bug ou adicionar uma funcionalidade só porque "está fácil" ou na cara não é refatorar e deveria ser evitado.

👉  Refatorar é alterar um código sem mudar o seu comportamento observável.

Por que refatorar?

O livro desenvolve a ideia de que todo software perde qualidade com o tempo e sua arquitetura fica obsoleta. Alguns dos motivos eu descrevo abaixo:

• O ambiente de desenvolvimento (linguagem de programação, framework, bibliotecas, infraestrutura...) evolui com o tempo e algumas decisões de arquitetura ficam obsoletas;
• Ao adicionar código seja para corrigir bugs ou adicionar funcionalidades, nós adicionamos dependências e débito técnico que se acumula com o tempo

Em vez de estressar a arquitetura e design ao extremo até o ponto de não podermos mais adicionar nenhuma funcionalidade, Martin Fowler propõe que a gente melhore a qualidade de nossos softwares com frequência.

Refatoração nos permite evoluir e atualizar a arquitetura de design do software constantemente. É importante refatorar porque desta forma evitamos a degradação do design do software de forma gradual em vez de investir em grandes correções e reescritas.

Quando refatorar?

O livro explicita dois momentos essenciais para executar uma refatoração: antes e depois de escrever alguma alteração no código.

Refatoração antes de alterar o código

Quando se investiga um bug, refatorar aquele pedaço de código é uma técnica muito útil para entender o que aquele código faz. E quando é necessário cobrir o código com testes, fica muito mais fácil. Normalmente durante a refatoração, o bug e sua correção ficam mais claros.

Por extensão, quando se precisa entender melhor o que determinado trecho de código faz, a refatoração também é uma ferramenta incrível.

👉  Sempre que você precisar escrever um trecho novo de código, refatore antes.

Refatoração depois de alterar o código

Quando a sua atualização estiver pronta para ser entregue, é o momento perfeito para refatorar mais uma vez. Este momento é a sua oportunidade perfeita para revisar suas alterações e garantir que a próxima pessoa que visitar aquele código vai entender com facilidade o que foi escrito. Provavelmente vai ser você quem vai visitar este código da próxima vez de toda forma, seja gentil consigo 😉.

Como eu já comentei no meu artigo sobre estilo de código para iniciantes, um comportamento chave de toda pessoa desenvolvedora experiente é escrever código para pessoas em vez de para computadores.

Outras oportunidades para refatoração após escrever o código podem aparecer durante um Code Review.

O que testes têm a ver com refatoração?

A definição que o livro dá sobre refatoração é: alterar um código sem mudar o seu comportamento observável.

Eu só conheço uma forma de provar que o software não passou a se comportar de forma diferente: através de testes. De preferência, testes automatizados.

É essencial que um código esteja coberto com testes antes de passar por uma refatoração. Do contrário você pode estar introduzindo bugs silenciosos sem sequer saber.

👉  Se você não tinha cobertura de testes antes de refatorar, você não está fazendo uma refatoração mas sim uma reescrita.

Refatorar sempre, em pequenos passos

Em resumo, devemos refatorar sempre que possível. Refatorar antes de escrever um código para que este possa receber as nossas alterações sem muita dificuldade, e depois de escrever um código como quem dá um acabamento ao trabalho.

Como eu comentei no artigo sobre como evitar programar por coincidência, a refatoração é o mise en place da pessoa programadora. Não deveria ser opcional, mas sim parte do nosso fluxo normal de trabalho.

É importante notar que o code review pode ficar muito confuso quando muitas alterações são feitas por conta de refatoração. Minha recomendação é refatorar sempre em pequenos passos, e testar o software após cada passo. O ideal é fazer um commit para cada refatoração aplicada.

👉  Para cada refatoração, faça um commit. Isso te ajuda a se organizar e a organizar o Code Review mais tarde.

Críticas ao livro Refactoring, por Martin Fowler

Todos sabemos que Martin Fowler é uma referência internacional quando se fala de desenvolvimento de software, mas ninguém é infalível.

Aqui, eu deixo algumas críticas minhas sobre o livro: são pontos de divergência ou apenas comentários que eu tenho e acho importante prestarmos atenção.

Quando falamos de desenvolvimento de software, quase tudo depende. Então é importante manter estas críticas em mente para evitar dogmatismo em torno do tema.

Definição de refatoração ao pé da letra não dá

Como eu comentei anteriormente, refatoração pode acontecer em diferentes níveis de abstração. Alterar a assinatura de uma função é considerado reescrita naquele escopo, mas ao observarmos um módulo pode ser considerado refatoração.

Da mesma forma, é possível reescrever partes de um módulo enquanto fazemos uma refatoração a nível de API REST.

O importante aqui é sempre refatorar somente com cobertura de testes e a pequenos passos incrementais. Quanto maior o seu nível de abstração, mais importante é mover-se a passos pequenos.

O que eu devo dizer ao meu gerente?

O livro diz brevemente como você, enquanto pessoa desenvolvedora, deveria justificar o tempo gasto em refatoração ao gerente/cliente. Afinal, refatoração consome mais tempo do que simplesmente escrever a sua funcionalidade.

O livro nos instrui a simplesmente omitir a refatoração ao nosso cliente. "O que dizer? Nada!". A justificativa do livro é que a refatoração vai facilitar a preparação do ambiente para que você faça as alterações que precisa.

Enquanto eu concordo com a justificativa, eu discordo sobre precisarmos nos calar sobre o esforço de refatoração. Da mesma forma como um profissional de saúde precisa usar máscara e luvas, nós precisamos refatorar.

Como já eu escrevi antes, refatoração é o mese en place da pessoa programadora. Não há necessidade de justificar a necessidade de refatorar um código, mas é necessário falar sobre e encorajar outras pessoas a fazerem o mesmo.

Dados duvidosos

Apesar de o livro trazer uma retórica bem convincente sobre refatoração, motivos para adotar a prática e como convencer seus colegas, a amostragem de dados é no mínimo... duvidosa.

No capítulo 2, o autor mostra um gráfico onde compara o montante de funcionalidades entregues com o tempo em projetos com bom design vs. projetos com mal design. De acordo com o gráfico, projetos com bom design tem crescimento linear, projetos com mal design têm uma tendência quase constante de entregas.

Mas o autor não apresenta nenhum dado concreto ou explica como chegou àquele gráfico.

Pessoalmente eu não vejo muito problema sobre falta de dados, as práticas se justificam por si só. Mas na minha opinião, toda pessoa quando falar sobre engenharia de software, deveria evitar fazer afirmações desta natureza sem dados concretos e disponíveis.

O que fazer com códigos legados?

O autor não dá muita informação sobre como lidar com sistemas legados e indica o livro Working Effectively with Legacy Code.

Na minha opinião esta indicação é horrível. Este livro é terrível e induz quem lê a fazer exatamente o contrário de refatorar: dar manutenção ao mal design do sistema.

Eu recomendo a leitura crítica do livro Working Effectively with Legacy Code, não acho que devemos ignorar esta literatura. Mas tenho MUITAS ressalvas com este título e recomendo atenção dobrada ao aplicar as dicas descritas nele.

Um exemplo mais em linha com o livro Refactoring, na minha opinião, é o livro Modernizing Legacy PHP Applications do Paul M. Jones. Apesar de ser específico à aplicações PHP, o livro adota uma prática 100% em linha com a descrita pelo livro Refactoring: pequenas alterações, modernização do design e pragmatismo.

Eu acho especialmente estranha a indicação do livro Working Effectively with Legacy Code porque o Martin Fowler já escreveu sobre StranglerFigApplication antes, uma forma de evoluir o design da aplicação como um todo.

Desmistificação do argumento da performance

Eu achei bacana que o livro buscou desmistificar o argumento da performance a todo custo. Já vi muito code review ser recusado por códigos como o seguinte:

lista.map(...).map(...).filter(...)

A justificativa? O map itera a lista inteira, encadear dois maps é ruim para a performance a lista inteira vai ser percorrida duas vezes. E o filter ao final vai reduzir o número de itens na lista. Seria ideal colocar o filter primeiro para que a lista inteira seja menor antes do map.

Faz sentido, mas dependendo do tipo de dado que o código está lidando, não faz nenhuma diferença na prática. Performance importa, mas micro otimizações podem ser ignoradas em favor de legibilidade de código.

Mas é importante não levar isto como dogma (dogmas em geral são ruins, principalmente em desenvolvimento de software). Performance é importante e as vezes uma refatoração pode causar danos imensos em termos de performance.

Busque o equilíbrio. Mas não aceite um code review recusado que use performance como desculpa sem trazer dados. Se a discrepância de performance estiver na magnitude dos nanossegundos, quase sempre pode-se ignorar com segurança a recomendação de melhoria performance.

Uma refatoração pode desfazer a outra, e tudo bem

Algo que o livro menciona brevemente mas eu acho importante destacar é que as vezes uma refatoração vai desfazer o que outra refatoração fez antes. E isto é normal.

A refatoração é um mecanismo que te ajuda a preparar o ambiente para receber seu código. Se voltar ao estado anterior é melhor para receber seu código, então voltemos ao estado anterior sem medo ou vergonha.

Considerações finais

O livro Refactoring, do Martin Fowler, é um dos livros base para toda pessoa programadora. Se você puder levar um único parágrafo deste texto todo contigo, leve este:

Para refatorar, é essencial ter cobertura de testes. Refatore antes de alterar o software. Refatore depois de alterar o software. Encoraje outras pessoas a fazer o mesmo!

E, claro, leia o livro e tire suas próprias conclusões.

Neste artigo eu mencionei três livros. Aqui os links para cada um:

• Refactoring: Improving the Design of Existing Code, por Martin Fowler

• Working Effectively with Legacy Code, por Michael Feathers
• Modernizing Legacy Applications in PHP, por Paul M. Jones

Até a próxima! 👋

A Lacrei é o primeiro portal criado para conectar a comunidade LGBTQIA+ a profissionais de saúde, advogades e empresas que respeitam a diversidade oferecendo oportunidades de trabalho e desenvolvimento profissional.

A plataforma facilita o contato e a informação para que pessoas LGBTQIAP+ possam encontrar, de forma prática e segura, serviços profissionais, acolhedores e inclusivos, de forma fácil e digital. Aqui, profissionais e empresas falam a nossa língua e escutam o que temos a dizer.

Em parceria com o blog Codamos, a Lacrei anuncia vagas de tecnologia para voluntariado em 4 áreas diferentes. São oportunidades incríveis para praticar suas habilidades e desenvolver seu portfólio com uma carga horária acessível e 100% remoto.

Todas vagas possuem carga horária de 10 horas semanais e são 100% remotas, para trabalhar com times que buscam diversidade

Vaga para Liderança técnica (Tech Lead)

As vagas são para candidatas mulheres, comunidade negra e comunidade LGBTQIAPN+.

A pessoa Tech Lead na Lacrei é uma pessoa técnica podendo ter atuação prática, pondo a mão na massa, apesar de liderar o time de desenvolvedores da Lacrei.

São dois times: um de back end e outro de front end, que se encontram semanalmente e participam de uma das 3 squads. São aproximadamente 25 pessoas voluntárias desenvolvedoras, em times multidisciplinares com pessoas de UX/UI, Front e Back -end.

Neste papel você terá a oportunidade de melhorar suas habilidades como pessoa programadora ao mesmo tempo que desenvolve aspectos de liderança. Nossos times utilizam a metodologia Scrum.

Parte de suas responsabilidades como Tech Lead é trazer as novidades tecnológicas e jeitos diferentes de resolver problemas de forma mais eficiente.

Além disso, a expectativa é que ela consiga manter o time focado no que precisa ser feito, priorize corretamente as atividades e entregue resultados tirando o melhor de cada membro do time.

Clique aqui para inscrever-se.

Vaga para Front-end (ReactJS)

As vagas são para candidatas mulheres, comunidade negra e comunidade LGBTQIAPN+.

Utilizamos a metodologia Scrum e atuamos juntamente com os times de UX/UI Design e Back-end dentro das Squads sempre com a supervisão das nossas Products Owners.

Nossa atividade voluntária compreende também a conversar com outras pessoas voluntárias, sua coordenadora e com sua Product Owner e comparecer virtualmente nas reuniões estipuladas.

Sendo assim, você deverá compreender a importância da Lacrei, ser empático com a comunidade e treinar a sua comunicação.

Times e Horários

Squad Institucional: Terça das 19 horas as 20 horas e Quarta das 19 as 20 horas.

Squad Jornada da Pessoa Profissional: Horários: Terça e Quarta das 19 às 20 horas.

Squad Jornada da Pessoa Usuária: Segunda das 19 as 20 horas e Quarta das 19 as 20 horas.

Requisitos

• NPM ou Yarn
• ReactJS e Gatsby
• Styled Components
• Consumir APIs
• Familiaridade com Git

Clique aqui para inscrever-se.

Vaga para Back-end (Python)

As vagas são para candidatas mulheres, comunidade negra e comunidade LGBTQIAPN+.

Python é uma linguagem de programação de alto nível, ou seja, com sintaxe mais simplificada e próxima da linguagem humana, utilizada nas mais diversas aplicações, como desktop, web, servidores e ciência de dados.

Hoje utilizamos outra tecnologia e estamos te convidando para fazer essa migração, aceita esse desafio!?

Requisitos

• Python
• Django
• PostgreSQL
• Testes unitários

Clique aqui para inscrever-se.

Vaga para profissional de Inteligência Artificial

As vagas são para candidatas mulheres, comunidade negra e comunidade LGBTQIAPN+.

Na plataforma Lacrei há vários filtros que uma pessoa usuária pode querer aplicar, e para oferecer uma experiência melhor desenvolvemos o nosso próprio algoritmo para extrair entidades de termos de busca usando o modelo Bert NER.

Estamos buscando programadoras de Inteligência Artificial e Aprendizado de Máquina para nos ajudar nessa caminhada.

Precisamos de alguém para criar e aperfeiçoar nosso algoritmo de Processamento de Linguagem Natural para extração de entidades, e essa é a sua tarefa nesse time.

Clique aqui para inscrever-se.

Se você quiser ajudar esta iniciativa mas não pode contribuir com tempo, compartilhe este post em suas redes - já serve de grande ajuda para o projeto!

A área de desenvolvimento de software é um tanto quanto peculiar quando se trata de fundamentos e verdades absolutas: são poucas as frases de efeito que são aceitas por unanimidade e não são seguidas daquele poderoso depende.

Um dos poucos fundamentos que normalmente sobrevive discussões é sobre a importância da estilização do seu código. É claro que há muita discordância e treta pela internet sobre qual estilo usar, mas ao menos todo mundo concorda que estilizar o código é essencial em diversos casos.

Este artigo não vai te apresentar nenhuma visão sobre qual estilo de código é o melhor, ou criticar estilos existentes. A minha intenção é munir você, dev júnior, com as ferramentas básicas que vão te ajudar a entender a importância da estilização de código e como isto vai afetar o seu aprendizado daqui pra frente - até o fim da sua carreira.

Dev júnior escreve pra computadores, dev sênior escreve pra pessoas

O motivo principal de eu escrever este artigo é que depois de várias sessões de mentoria com iniciantes tanto no front-end quanto no back-end percebi que muitas das confusões e dificuldades que essas pessoas tiveram poderiam ser mitigadas com a adoção de algumas boas práticas sobre estilo de código.

Eu já perdi a conta do número de sessões em que mentorandes chegaram para mim com quilos e mais quilos de código para resolver problemas simples, sem entender o que aquele espaguete estava fazendo. Ao mesmo tempo, já compartilhei códigos super complexos que qualquer júnior com o mínimo de conhecimento consegue entender e modificar.

A diferença é simples: dev júnior costuma escrever código que máquinas apenas entendem, enquanto dev sênior costuma escrever código para que pessoas entendam.

O maior erro de quem inicia na programação é achar que a forma como se escreve código não faz diferença. Vejamos um exemplo:

const words = ['Hello', 'world']
let sentence = ''
for (const i in words) {  
  sentence = sentence.concat(words[i])
  if (i < words.length - 1) sentence = sentence.concat(', ')
}

console.log(sentence)

O código acima deverá cuspir na tela o valor Hello, world e nada mais, certo? Errado!

O código acima cria três variáveis e deixa duas delas no escopo local, sem contar no montante de operações desnecessárias. Na verdade,  o código acima poderia ser simplificado para algo assim:

const sentence = ['Hello', 'world'].join(', ')
console.log(sentence)

E aqui eu deixo claro o seguinte: código complexo é diferente de código complicado!

Uma boa definição de complicado que se adequa ao que quero dizer, lá do dicio, é algo "Exageradamente detalhado; que possui elementos em demasia [...]".

Enquanto a definição de complexo por lá nos diz que é uma "Construção com inúmeras partes que estão ligadas entre si, formando um todo [...]". O que a gente considera engenhoso, na minha opinião. Que é justamente o que a nossa profissão se propõe a fazer.

A primeira chavinha que eu quero te ajudar a virar, dev júnior, é a de entender que código complicado vale menos do que código complexo. Código bom é o que nós dois conseguimos ler!

Abaixo eu vou descrever um pouco mais sobre o porquê de ser essencial você aprender a estilizar código desde já!

Estilizar o código te ajuda a pedir ajuda

Vamos partir de um pressuposto simples: "Hey, me ajuda!" é bem diferente de "Hey, faz pra mim?". Por isso o jeito certo de pedir ajuda é reduzir o problema ao máximo possível.

Uma das grandes fontes de confusão e dificuldade na hora de pedir ajuda, é localizar o problema. Vamos ver um exemplo?

/**
 * Hey, me ajuda? O compilador diz que deu pau na linha 2
 */
1. ((function(){console.log( a + 1 / 100
2. );}

É somente natural que você não entenda onde está o problema. Eu mesmo não faço a menor ideia de o que tá acontecendo ali.

Com o código um pouco mais organizado talvez você nem precise pedir ajuda. Vamos isolar cada bloco em sua própria linha e ver o que aconteceu:

1. (
2.   (
3.      function () {
4.        console.log(a + 1 / 100)
5. // ...

Depois da linha 5 ficou claro que faltaram alguns parênteses e chaves. Uma chave } para fechar o escopo da função, dois parênteses pra fechar a expressão das linhas 1 e 2.

Estilizar seu código vai te ajudar a entender o que VOCÊ está fazendo em primeiro lugar. E torna muito mais fácil para outras pessoas te ajudarem mais tarde.

Como dizia minha incrível mãe: casa simples não é desculpa pra ser suja. Eu espero que você adote isso como uma regra de etiqueta: pedir ajuda com um código porco e mal formatado é uma falta de respeito enorme. Sempre mantenha a casa limpa!

Espero que tenha ficado clara a importância de estilizar o seu código enquanto iniciante no mundo da programação. Agora vem comigo, que eu vou te explicar o que eu quero dizer com estilo de código.

O que é estilo de código

A metáfora da casa limpa se aplica muito bem aqui. No fim das contas você, e qualquer outra pessoa desenvolvedora, deveria ser capaz de navegar no código que escrevem com facilidade.

O estilo de código adota regras que afetam vários aspectos do seu software. Algumas destas regras são sobre:

• estilo de formatação;
• regras de indentação de código;
• regras para quebra de linha;
• limite de caracteres por linha;
• nomenclatura de variáveis, funções, classes e métodos;
• organização em pastas e nomes de arquivos;
• outras boas práticas

Não adianta apenas adotar um estilo de código. É importante ser consistente com aquele estilo.

Por exemplo, se você indentou um arquivo JavaScript com 2 espaços, o próximo arquivo não pode ser indentado com 4 espaços.

Para o computador, tanto faz se você usa 2 ou 4 espaços para indentar. Mas lembre-se: o computador é só mais um elemento na enorme lista de consumidores do seu código. Escreva código para pessoas, não para computadores!

Quebra de linha tá aí pra ser utilizada

Parece besteira, mas faz toda a diferença!

Gente, nós estamos  em 2022! Uma quebra de linha custa o que? 2 bytes? Não tem motivo pra economizar linha, né.

Bora quebrar linha sem dó! Saiu um ponto e vírgula? Dá-lhe enter!

Bate o olho e me diz o que esse código faz:

const primeira = 10; const terceira = 20; const segunda = 30;
console.log(primeira, terceira, segunda, primeira * 2);

Agora bate o olho nesse aqui e me diz o que ele faz:

const primeira = 10;
const terceira = 20;
const segunda = 30;

console.log(
  primeira,
  terceira,
  segunda,
  primeira * 2
);

Faz sentido eu quebrar linha até mesmo dentro do console.log? No fim das contas fica mais fácil ler o que eu tô passando pra dentro da função.

A época dos monitores de 320x240 pixels já passou faz tempo, gente. Vamo sem meguelar quebra de linha!

Indentação de código

Indentação é quando a gente afasta o código da margem pra organizar. Quando se abre um bloco de código, normalmente é hora de indentar.

Aqui um código não indentado:

function euOdeioAMinhaVida() {
const motivo = 'Porque eu não indento código!';
if (motivo.length > 100) {
console.log('Mó filosofia do ódio')
}
else
{
console.log('E o motivo é simples:', motivo)
}
}

Um código parecido, mas com indentação:

function euAmoAMinhaVida() {
  const motivo = 'Porque eu indento código!';

  if (motivo.length > 100) {
    console.log('Olha que delícia essa indentação')
  } else {
    console.log('E o motivo é simples:', motivo)
  }
}

No bloco de código do corpo da função euAmoAMinhaVida() eu adicionei uma indentação. Lá dentro tem alguns IFs. Pro bloco de cada IF, eu adicionei mais uma indentação.

Tem gente que se importa sobre o seu código usar Tabulações ou Espaços para indentação. Tem gente que se importa ainda se ao indentar com espaços você usa 2, 4 ou 6 espaços...

Tanto faz!

O importante é indentar o código sempre e ser consistente com seu estilo de indentação. Se começou usando 2 espaços, continua com 2 espaços. E por favor não caia na besteira de indentar um arquivo com 2 espaços, outro com 4, outro com 6 e montar uma salada de indentação. Consistência!

Claro que a indentação por si só não é suficiente para escrever um código bom e que todo mundo vá entender. O Hadouken que o diga:

Ferramentas automatizadas

Daí você me pergunta: tá, mas como eu sei qual o jeito certo de estilizar o código? Tem de quebrar linha no lugar certo, tem de indentar do jeito certo... Onde eu acho isso tudo?

Cada linguagem de programação tem sua comunidade e suas convenções. Você precisa procurar entender a de cada linguagem com que pretende trabalhar.

Para a nossa sorte, existem ferramentas que controlam e dizem pra gente quando algo está errado. Algumas até corrigem o código pra gente!

No mundo JavaScript/TypeScript tem o tal do Eslint. No mundo PHP, tem o PHP Code Sniffer. O Rust tem o rustfmt e por aí vai.

O bom de usar uma ferramenta automatizada, é que você vai desenvolver a "memória muscular" de como escrever código sem precisar decorar milhares de regras pra cada linguagem.

Dica de ouro: sempre que fizer um coding challenge pra passar naquela entrevista, adicione um linter como o eslint ou phpcs. Vai te dar alguns pontos na avaliação 😉.

Escolha de nomes para variáveis e funções

O nome é importante, gente. Vamos combinar aqui: variável a, b ou c não faz o menor sentido a não ser que você esteja fazendo um programa pra solucionar equações de segundo grau! E eu não quero nem ver variável tmp, ein...

Todas as regras que se aplicam a nome de variáveis também se aplicam a classes, métodos e funções.

Vamos combinar três cláusulas pétreas aqui, tá?

1. Não abrevie nomes: fmt não faz sentido NENHUM! Use o nome completo, não precisa economizar bytes em disco;
2. Sem nomes sequenciais: line, line2, line3... Isso é coisa de maluque! Precisa de uma lista? Use uma lista e pronto!
3. Dê significado semântico pros seus nomes: o nome precisa fazer sentido no contexto em que está inserido. Deixa eu explicar um pouco melhor...

Eu já trabalhei numa empresa que dizia o seguinte: toda variável precisa ter um prefixo que indica o tipo dela. Uma variável var do tipo inteiro se chama iVar, do tipo boolean bVar, do tipo float fica fVar.

Gente, o ano é 2022! Sua IDE e ferramentas de análise estática já vão garantir o tipo de uma variável. Não tem motivo prefixar ou sufixar variável com tipo. Isso não adiciona nenhum sentido semântico.

Agora quer ver como a semântica muda a compreensão de código? Olha aqui:

if (number % 2 === 0) {
  // ...
}

O código acima faz exatamente a mesma coisa que este aqui:

const isNumberEven = number % 2 === 0

if (isNumberEven) {
  // ...
}

Qual IF você entende com mais facilidade?

Pela semântica, vale tudo! Até criar variável "inútil". Estamos em 2022, você não precisa economizar bits e bytes. Criar uma variável a mais não vai comer sua memória RAM e de quebra vai economizar um tempão de quem lê seu código, inclusive você!

Como mecanizar estas práticas

E a coisa é esta mesmo: mecanizar. Você precisa adotar estas práticas automaticamente, quase sem pensar!

Aqui vão algumas dicas pra não se perder nas regras.

Feche blocos imediatamente depois de abrir

Já se deparou com a situação em que abriu um parêntese, e depois outro, e mais outro e mais outro, e acaba precisando contar parênteses pra saber onde fechar o que?

a + (b * c ( x + y + (d ^ 2)) + 10)

Sai dessa vida, gente... Ficar contando parêntese, pára com isso...

Abriu o parêntese? Fecha imediatamente e continua só depois! Abriu chaves? Fecha imediatamente e continua só depois! Seu código vai te exigir pular linha? Pula a linha primeiro e depois volta pra onde tava!

if () {
}

Sabe esse IF aí em cima? Eu quero que você prometa pra mim que só vai escrever a condição dentro dos parênteses depois que tiver digitado o ).

Cuide primeiro da sintaxe, depois da semântica! Abriu parêntese, fecha imediatamente. Abriu chaves, fecha imediatamente.

A regra dos 80 caracteres

Se tu tiver usando uma tela grande pra ler este texto vai reparar que eu não deixo o texto usar a sua tela toda. Sabe o motivo? Porque tu não iria ler, simples assim.

Linhas longas não são lidas! Quanto maior a linha, menor a atenção que ela vai receber.

Uma regra comum é a de quebrar a linha depois de um limite. Algumas comunidades adotam 80 caracteres, outras 120. Adote um e seja feliz.

A maioria dos editores de código vão te ajudar com isso ao colocar uma linha vertical no meio na sua tela. Se o seu código encostar nesta linha, é hora de quebrar linha.

Agora, atenção ein! Não vai quebrar a linha como quem joga entulho no quintal do vizinho! Se você quebrar linha no contexto de elementos separados por vírgula, dê uma linha para cada elemento.

Não faça isso:

echo sprintf('Minha string %s formatada %d vezes', 'Nawarian',
  10);

Faça isso:

echo sprintf(
  'Minha string %s formatada %d vezes',
  'Nawarian',
  10
);

E note que o parêntese que fecha a função sprintf está alinhado verticalmente com o começo da linha que abriu aquele parêntese. Além disso, os parâmetros, cada um em sua linha, estão indentados uma única vez.

Linhas grandes não são lidas, são feias que dói e deveriam te causar repulsa! Quebre a linha sempre que precisar e use uma regra padrão.

Escreva seu código duas vezes

No início da nossa carreira a gente costuma escrever código e se funcionar, funcionou! Segue o jogo.

Você precisa cortar este hábito o quanto antes!

Sempre que você terminar de escrever um código, volte ao começo e leia tudo de novo pra ver se tem algo que você pode deixar mais claro.

Lembre-se: você quer escrever código para outras pessoas lerem, não só para o computador ler.

Uma quebra de linha, um nome de variável melhor, uma modificação na lógica... tudo isso pode ajudar bastante.

Vou te dar um exemplo. Olha o seguinte snippet de um emulador que eu escrevi:

function readZeroPage(): int
{
  return $this->bus->read($this->state->pc++) & 0xFF;
}

Sim, estou escrevendo um emulador de Nintendinho 8-bit. Dá uma olhada no meu Devlog sobre como criar um emulador de NES pra aprender como fazer o seu.

O exemplo acima está bem simplificado pra quem entende o domínio. Mas se eu quiser simplificar para que todo mundo possa entender com menos dificuldade, poderia ter algo assim:

function readZeroPage(): int
{
  $address = getProgramCounterAddress();
  incrementProgramCounter();

  $zeroPageValue = $this->bus->read($address);

  return asInt8($zeroPageValue);
}

O que é um código bom ou legível é totalmente subjetivo e depende não só de quem lê, mas também do contexto. No caso do desenvolvimento de um emulador de CPU os conceitos de pc, bus, zero page e int8 são bem comuns. Mas é inegável que o segundo exemplo de código explica muito mais sobre o que está acontecendo do que o primeiro.

Depois de escrever seu código - seja uma página, uma função ou um mesmo um IF - releia tudo para identificar se você pode tornar o contexto mais explícito e comunicar a sua intenção com código.

Não escreva código como é ensinado em cursos e faculdades

Existe um problema muito comum com iniciantes que acabaram de ver um curso ou estão na faculdade. O código das pessoas nessa fase normalmente é BEM RUIM de entender.

Isto porque nos cursos nós ensinamos conceitos, métodos e técnicas. O estilo de código fica secundário e dá mais trabalho de ensinar ao mesmo tempo.

Especialmente em faculdades, professores mais velhos - com todo o respeito, nós devemos a modernidade a estes profissionais - adotam costumes que eram comuns há algumas décadas atrás, quando precisávamos economizar espaço a todo custo e conseguíamos parar em frente a um texto por mais de 1 hora sem receber uma notificação de que alguém está tretando no Twitter!

Boa parte das práticas que são adotadas durante cursos (alô variável temp!) precisam ser extintas do seu vocabulário! Absorva o conteúdo, não o estilo!

E pra deixar claro, o problema não são os professores mais velhos. O problema é que professores normalmente não escrevem código profissionalmente há alguns bons anos.

Adote o estilo de profissionais que trabalham com desenvolvimento software, não ensinando desenvolvimento de software. São duas profissões distintas!

O mais importante te tudo: leia código de pessoas mais experientes

Fica claro que se você não pode confiar no código de quem te ensina código, precisamos buscar inspiração noutro lugar.

Como eu disse antes, cada linguagem tem as suas comunidades, convenções e estilos. Cabe a você aprender os estilos que lhe interessam.

Aqui vão algumas dicas de como achar essa inspiração.

Navegue no Github em busca de Pull Requests

Pull Requests são incríveis fontes de conhecimento sobre como as outras pessoas escrevem código.

Olha este exemplo do repositório aberto do Monolog. Você consegue ver quais arquivos foram modificados, onde e como. Além disso, os responsáveis pelo repositório adicionam comentários e perguntas sobre o código.

Uma das melhores formas de aprender como escrever código de acordo com o estilo da sua comunidade, é lendo pull requests enviados para esta comunidade.

Mais efetivo ainda é você enviar um pull request e receber comentários de volta. A comunidade ganha, você ganha, todo mundo ganha!

Navegue nos repositórios da sua empresa

No contexto de uma empresa, o melhor é ver como as outras pessoas já operam.

Normalmente se a empresa é moderna no quesito desenvolvimento de software, esta será uma fonte incrível. Mas se você duvida da qualidade do código e das pessoas que o produzem, ignore esta dica - e procure outro emprego o quanto antes.

Participe, mesmo que como ouvinte, de discussões sobre estilização de código

O que eu disse lá no começo é muito verdade. Tudo depende, e muitas pessoas desenvolvedoras gostam de discutir de fundamentos a nuances sobre estilo de código.

Participe destas discussões o quanto puder: em reuniões, em conferências, em fóruns, no Twitter... Não importa se você estiver errade! Se alguém te corrigir você terá aprendido. Mas o mais importante é ver outras pessoas trocando conhecimento e opiniões também.

Voa, juninhe! Voa!

É claro que eu escrevi este artigo num tom mais energético e duro, mas a intenção não é te desmotivar.

Eu quero que estilo de código seja algo natural pra ti, e que você incorpore estas dicas no seu dia a dia de forma automática pra que possa focar na lógica que está aprendendo, em vez de se preocupar com bobeiras de estilo.

Se a estilização for tarefa mecânica pra ti, vão te ficar disponíveis muito mais neurônios pra focar no que importa: resolver o seu problema de código.

Vai que a sua jornada tá só começando e o futuro é próspero! Voa, juninhe! Voa!

Compartilha este texto com a galera pra ajudar e trazer pra discussão, belezera? Te vejo na próxima.