Pequeno Princípio

Eu acho o livro O Pequeno Príncipe um dos livros mais incríveis já escritos. Acho, inclusive, que a introdução já vale ouro por si só.

A frase mais conhecida desse livro certamente é:


"Tu te tornas eternamente responsável por aquilo que cativas"

Eu sou fã de alguns princípios interessantes para o mundo do software, como o Princípio Greyhound: "Leave the driving to us"

Ou o Príncipio Broadway: "Don't call us. We'll call you"

Esses dois últimos descrevem os frameworks e servem para diferenciá-los de bibliotecas.

Eu adaptei a frase do Saint-Exupéri e criei um pequeno princípio para o desenvolvimento de software: "Tu te tornas eternamente responsável pelo software que escreves" 

É uma lembrança de que o software não é como pão numa padaria: cada linha escrita vai exigir manutenção, suporte, e os erros voltam para nos assombrar.

Tenho pensado nisso porque tenho ouvido muito que "é preciso fazer mais com menos", mas penso que, pelo contrário, é preciso fazer menos. É preciso ater-se ao essencial; ao que realmente agrega valor ao negócio.

Além disso, é preciso dar tempo ao desenvolvimento para que os sistemas não acabem gerando mais suporte do que é possível oferecer. É fácil que a equipe de desenvolvimento acabe num ciclo vicioso de não ter tempo para agregar funções, porque está gastando todo o seu tempo com suporte.

Alguns clientes não essenciais da empresa ganham horas de desenvolvimento quase que por caridade. Existe a noção de que, para sermos justos, devemos dar um pouco de tempo do setor de informática para todo mundo. Mas todo tempo gasto com ações periféricas e não essenciais rouba tempo daquilo que é essencial; rouba tempo hoje e roubará mais adiante quando for preciso dar suporte.

Ademais, nem tudo precisa ser um software novo: muitas coisas podem ser resolvidas com processos e ferramentas de prateleira (ou até mesmo com notas de post-it).

Como Clonar Todos os Projetos de um Grupo do Git

O primeiro passo é criar um token de autenticação para poder usar a API. Então, em suas configurações, procure por Tokens de Acesso (Access Tokens) e crie um para usar a API em modo de leitura. Defina uma data de vencimento para manter sua conta segura.

Um vez criado o token, vá ao grupo que deseja clonar e anote o número (porque ele será usado na chamada à API).

 curl "https://git.acme.com/api/v4/groups/$GRUPO?private_token=$TOKEN" \
   | jq .projects[].ssh_url_to_repo \
   | tr -d '"' \
   | xargs -I{} git clone {}

Troque $GRUPO pelo número do grupo e $TOKEN pelo token criado para autenticar.

Um comando alternativo:

 curl "https://git.acme.com/api/v4/groups/$GRUPO/projects?private_token=$TOKEN" \
   | jq  .[].http_url_to_repo \ 
   | tr -d '"' \
   | xargs -I{} git clone {}
   

Separei o comando em 4 partes:

• O curl busca um json que descreve o grupo e todos os projetos;
• O jq extrai de cada projeto a url de acesso;
• O tr retira as aspas que circundam a url do projeto;
• O xargs executa o git clone para cada projeto.

Agora, para buscar alguma coisa em todos os projetos, pode-se usar o find.

find . -type f -exec grep -Pi "my_funny_var" /dev/null {} \; > search.txt

Neste caso, procuro por "my_funny_var". As opções usadas são:

• -type f - analisa apenas arquivos;
• -exec - executa esse comando para cada arquivo encontrado;
• -Pi - usa expressões regulares do Perl (porque permitem agrupamentos, opções, etc) sem considerar a caixa.
• /dev/null - é um nome de arquivo extra para obrigar o grep a imprimir o nome do arquivo antes da linha encontrada (como estamos pesquisando por vários arquivos, queremos identificar cada um nos resultados).

Teorema de Herão

O teorema de Herão é uma dessas coisas que, inexplicavelmente, não ensinam na escola. Ele permite calcular a área de um triângulo (e, consequentemente, de outras formas geométricas) usando apenas os comprimentos dos lados.

Dado um triângulo (a, b, c) com perímetro P (a+b+c) e semiperímetro S (P/2), podemos calcular a área A com:

A=sqrt[S(S-a)(S-b)(S-c)]

Dada uma maneira fácil de calcular A, podemos automatizar a busca por triângulos especiais. Por exemplo, todos aqueles cuja área é igual ao perímetro.

#!/bin/perl
use strict;
use warnings;

for my $a (1..1000) {
  for my $b ($a..1000) {
    for my $c ($b..1000) {
      my $P=($a+$b+$c);
      my $S=$P/2;

      my $A=$S*($S-$a)*($S-$b)*($S-$c);

      if($A>0) {
        $A=sqrt($A);
        print "($a, $b, $c) => $A\n" if int($A)==$A && $A==$P;
      }        
    }  
  }
}


(5, 12, 13) => 30
(6, 8, 10) => 24
(6, 25, 29) => 60
(7, 15, 20) => 42
(9, 10, 17) => 36

Ou então, todos cuja área é metade do perímetro: apenas (3,4,5) com área 6. Nenhum tem área menor que S.