$: Existem facilidades ao uso da plataforma Mac Os, e Linux, como os dois são baseados em Unix, seus comandos são os mesmos, alguns sao muito bons, e irei fazer uma lista de usos dos mesmos para facilitar a vida de quem esta iniciando em um Ubuntu ou Mac os. Alguns comandos sao simples, apesar disso, ainda pouco utilizados.

SCP – Secure Copy
Uso Comum:
$: scp meuarquivo.txt usuario@computador_ou_ip: /pasta/arquivo\

Com recurso de modificação da porta:
$: scp minhapasta/ usuario@ip_ou_computador: /pasta/destino/ -p 92366

Unzip – Decompress file
uso comum:
$: unzip arquivo.zip

Uso com criação de pasta:
$: unzip -qd arquivo.zip

Mysql Dump – Dump Databases
Uso comum:
$: mysql -h localhost -u root -psenha minha-base > arquivo.sql

Uso comum para todas as bases:
$: mysql -h localhost -u root -psenha –all-databases > arquivo.sql
Nota: Note que o -p = senha, e sempre colado no -p mesmo. Sendo assim -psuasenha.

Cal – Simples Calendario no Shell
Uso comum:
$: cal

Retorno:

December 2009
Su Mo Tu We Th Fr Sa
1 2 3 4 5
6 7 8 9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28 29 30 31

Para obter dos ultimos 3 meses:
$: cal -3

Para obter os calendarios de algum mes de um ano anterior:
$: cal 10 2000

October 2000
Su Mo Tu We Th Fr Sa
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31

Nota: Para outros formatos consulte: cal –help.

Find – Obtenha resultados rapidamente!
Consulta rapida na pasta para um arquivo:

$: find -name ‘meu_arquivo.htm’

Ou
Consulta geral para um arquivo:
$: find / -name ‘meu_arquivo.htm’

Nota: Isso pode ser bem demorado… Recomendo algo como indicar a pasta para otimizar o resultado da busca:
$: find /home/meuperfil -name ‘meu_arquivo.htm’ ;

Você tambem pode procurar por tamanho de arquivo:
$: find -name ‘*’ -size +1000k

Ou caso nao lembre o tipo de arquivo, somente parte do nome:
$: find -name ‘meu_arquivo*’

O retorno e algo como:

meu_arquivo.htm,
meu_arquivo.txt,
meu_arquivo.png …..

Bom, essa lista so tende a crescer, em breve, irei atualizando e informando que a mesma foi atualizada, ou pelo twitter ou em novos posts ;)

Caso queiram contribuir com seus comandos mais usados e praticados, para facilitar a vida, basta ir enviando nos comentarios e irei adicionando.

“P#%#$, nunca entendi direito o que é método ou atributo nessas paradas de oo, é por isso que eu me enrolo tanto, me explica ae.”

Ouvindo isso eu pensei, como eu vou fazer pra essa anta esse meu amigo entender esse conceito de forma rápida?

Ele mesmo me respondeu sem querer com a seguinte mensagem: (sim, o assunto muda rápido mesmo)
“… Aew, tu viu aquela morena gostosa do BBB? C@#$@#$ ela é muito boa mesmo…”

Pronto, o jeito mais prático de explicar os conceitos de OO pra esse cara seria utilizando mulheres como exemplo, wtf? sim, sim, e acreditem funcionou muito bem os exemplos e a idéia me pareceu tão boa que valeu um post aqui.

História contada então vamos ao que interessa.

Vejamos a foto abaixo:

Essa coisinha bunita da foto acima é a Hitomi e ela vai ajudar a gente a aprender o que é o que em Orientação a Objetos. Então olhamos a foto e vemos? uma gostosa… deitada num sofá… então,… o sofá tem 4 pernas, 1 estofamento… calma, calma, to só brincando.

A primeira coisa que precisamos entender quando vamos programar orientado a objeto são os atributos, e que atributos amigo.

Pensando nisso teriamos a seguinte classe para a foto acima:

<?php
 
class HitomiTanaka
{
  //Atributos realmente importantes
  protected var $peitos = 'KING SIZE';
  protected var $bunda = 'Na medida';
 
  //Atributos importantes mas que passam batido na visão
  protected var $olhos = 'Castanhos'; //Se tiver errado me perdõe, não consigo vê-los tempo suficiente sem desviar a visao na foto acima
  protected var $cabelo = 'Castanho'; //idem ao anterior
  protected var $peso = '50kg'; //Não faço idéia, mas acho que ela não ia ficar triste com esse chute :P
  protected var $roupas = 'Vestidinho Roxo'; //Aqui o defaul poderia ser "nenhuma"
?>

Isso da pra ter uma noção do que são atributos numa classe certo?

Sabendo disso, vamos por a mente pervertida pra trabalhar e pensar nos métodos, que são nada mais nada menos que as ações, coisas que a classe faz.

Olhe novamente outra foto da hitomi, dessa vez mostrando um pouco mais os atributos…

Olhando a foto acima, e depois de censurar um pouco os meus pensamentos, achei métodos que poderiam ser incluídos nesse post, estão na classe abaixo.

<?php
 
class HitomiTanaka
{
  //Atributos realmente importantes
  protected var $peitos = 'KING SIZE';
  protected var $bunda = 'Na medida';
 
  //Atributos importantes mas que passam batido na visão
  protected var $olhos = 'Castanhos'; //Se tiver errado me perdõe, não consigo vê-los tempo suficiente sem desviar a visao na foto acima
  protected var $cabelo = 'Castanho'; //idem ao anterior
  protected var $peso = '50kg'; //Não faço idéia, mas acho que ela não ia ficar triste com esse chute :P
  protected var $roupas = 'Vestidinho Roxo'; //Aqui o defaul poderia ser "nenhuma"
 
  //
  public function mostrar($parteDoCorpo) 
  {
    //Aqui ficaria toda a rotina de desabotoar ou abaixar o sutian...
  }    
 
  public function balancar() 
  {
    //Niiiiiice, Imaginem a única cena que presta do filme click...
  }    
 
  public function striptease() 
  {
    //Ahhhhhhhhh!!!!
  }    
 
  /*
   Os outros 239 métodos que eu pensei envolveriam 
   interações com a classe Eu e seriam classificados como NSFW
   por isso não foram incluídos.
  */  
}
 
?>

Então… serviu pra ter uma noção do que são métodos né? acho que sim… mas como exercício de fixação, deixo para os leitores a feliz tarefa de comentar métodos e atributos que poderiam ser incluídos na nossa classe.

E como sempre, dúvidas sugestões e qualquer outro puxão de orelha, comentários tão ai pra isso.

Bom o post de hoje é pequeno e rápido e com certeza incrívelmente útil, vou mostrar hoje uma técnica que estou usando pra facilitar minha vida na hora de desenvolver meus códigos, o assunto de hoje é o __autoload, uma funçãozinha que está me economizando preciosos minutos no desenvolvimento.

O funcionamento dele é básico, e funciona assim:

Quando você tenta instanciar uma classe o php verifica se essa classe já existe, se não existir ele tenta carregar ela de acordo com a função __autoload que estiver no script.

ex:

1
2
3

function __autoload($class_name) {
	require_once $class_name.'.php';
}

digamos que em algum momento do meu código eu tentei instanciar a classe Groups

1

$groups = new Groups;

se a classe Groups não existir até o momento o php vai tentar incluir o arquivo Groups.php (de acordo com a minha função __autoload) antes de disparar um erro. Ta mas ele sempre vai procurar só pelo nome da classe? depende… tudo depende de como você faz a sua função __autoload, veja o exemplo abaixo para entender.

1
2
3

function __autoload($class_name) {
	require_once 'my/path/to/classes/'.$class_name.'.php';
}

nesse exemplo acima o php vai procurar pela classe na path determinada na função antes de disparar o erro.

Bom é isso, só pra terminar vou dar uma dica que eu estou usando aqui, que é simplesmente adicionar as paths de onde as classes estão ao include_path.

1
2
3
4
5
6
7
8
9

<?php
 
set_include_path(get_include_path() . PATH_SEPARATOR . './libs/');
 
function __autoload($class_name) {
	require_once $class_name.'.php';
}
 
?>

Vou explicar o código:

3

set_include_path(get_include_path() . PATH_SEPARATOR . './libs/');

Adiciona ao include_path do php a pasta ./libs/

5
6
7

function __autoload($class_name) {
	require_once $class_name.'.php';
}

Define a função __autoload que irá procurar pelas classes quando forem instanciadas.

Ufa… cabou, é isso ai gente, como sempre dúvidas, sugestões e puxões de orelha nos comentários por favor :D.

abraço e até a próxima,
ps. esse foi o post mais rápido que eu já postei, da idéia de postar até o fim da revisão do texto demorou 26 min oO.

Vou começar uma série de posts rapidos com dicas legais e uteis pro dia-a-dia relacionadadas a PHP.

Quase todos usam Twitter, e ja sabemos o o Twitter tem uma API para integração, porem nao e necessario usar uma API para algo basico, como pegar os Ultimos posts de alguem via RSS. Ja que RSS e um formato XML.

Abaixo um codigo simples e rapido:

1
2
3
4
5
6
7
8
9
10
11
12

<?php
$rss = 'http://twitter.com/statuses/user_timeline/14627317.rss'; 
$abre = simplexml_load_file($rss);
$i = 0 ; 
$limite=3;
foreach ($abre->channel->item as $itens ) {
$post = utf8_decode($itens->title);
echo $post .'<hr />';
if($i==$limite) { break; }
$i++;
 }
?>

$rss
Indica o caminho completo do RSS a ser lido.

$abre
Utiliza simplexml_load_file para ler o xml e converter em um objeto/p

$i
Define o inicio do loop para que possamos frear o loop no nosso limite de twittadas./p

$limite=3
Definimos um limite de posts, no caso como nosso loop comeca em em 0, definindo 3, o limite de posts seria 4: 0,1,2,3

foreach ($abre–>channel->item as $itens ) {
Aqui criamos um loop do item do XML e o chamamos de $itens para melhor identificação dentro do loop.  Aqui ele herda os itens de channel->item, como title, e outros

$post = utf8_decode($itens->title);
Aqui usamos o UTF-8 para decodificar as mensagens evitando erros de charset e podemos interpretar para o ISO.

echo $post .’ < hr / >‘;
Aqui imprimos o Post na tela e adicionamos a tag

if($i==$limite) { break; }
Aqui verificamos se o nosso loop chegou ao nosso limite definido acima, se chegar coloca um fim no loop do channel->item

Por fim e isso, basta usar em seus blogs, e onde mais desejar ;)

Neste artigo vou falar do método mágico __call(),  que funciona da seguinte maneira:

Quando uma classe tem o método __call() o php roda esse método sempre que qualquer método da classe for chamado, mesmo se o método que foi chamado não existir um método inexistente ou inacessível for chamado (obrigado Edgar pelo puxão de orelha), isso abre espaço para algumas coisas interessantes.

Vamos a um exemplo do funcionamento de __call():

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

<?php
class ExemploCall {  
  function __call($m, $a)
  {
    print "Método chamado: $m\n";
    print "Parametros: \n";
    var_dump($a);
    return $this->x;
  }
}
$call = new ExemploCall();
$call->test(1,2,'teste');
 
//Mostra na tela
/*
Método chamado: test 
Parametros: 
array(3) { 
  [0]=>  int(1) 
  [1]=>  int(2) 
  [2]=>  string(5) "teste" 
} 
*/
?>

O exemplo acima simplesmente exibe na tela o método chamado e os parametros enviados, mas vendo isso a pergunta que surge na cabeça é, pra que ou onde eu vou usar o método __call()?

A resposta pra essa pergunta vai da sua criatividade mas eu vou postar aqui uma forma de uso que o cakephp usava há algum tempo atrás.

Funcionava da seguinte forma, havia um método padrão chamado find que era chamado e fazia consultas ao banco de acordo com os parametros passados, porém, (aqui que vem a mágica) ele também podia ser chamado como findByNomeDoCampo o que em alguns momentos facilitava bastante a vida do programador, vamos fazer algo parecido com isso.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

<?php
 
/**
  Só vou postar o código relevante aos métodos mágicos, mas supõe-se que
  deste ponto em diante você já tem incluido no arquivo toda a rotina de 
  conexão com o banco de dados, etc, etc, etc...  
**/
 
class Model {
 
  public function __construct() 
  { //O conteúdo deste método vai variar de acordo com sua classe
  }
 
  public function __call($method, $params)
  {
    // Verifica se o método chamado existe nessa classe
    if ( method_exists($this,$method) )
    {
      //Caso exista chama o método
      return call_user_method($method, $this, $params);
    } 
    else 
    {
      //Caso não exista, chama um método especial que fará a nossa mágica
      $this->parseMethods($method,$params);
    }
  }
 
  private function parseMethods($method,$params)
  {
    //Verifica se o método segue o padrão adotado
    if ( eregi('findBy',$method) === false ) 
    {      
      //Caso não siga dispara um erro dizendo que o método é inválido/não encontrado
      trigger_error('Método inválido ou inexistente',E_USER_ERROR); 
      die;
    }
    else
    {
      //Caso seja um método padronizado (findByAlgo) recupera o nome do campo e converte tudo para minúsculo
      $fieldName = strtolower(str_ireplace('findBy','',$method));      
 
      //Formata os parametros para serem passados ao método find padrão
      $options = $params['1'];
      $options['conditions'] = array($fieldName=>$params['0']);
 
      //Chama o método find original
      $this->find($options);            
    }
  }
 
 
  public function find($options) 
  {    
    var_dump($options);
    //Aqui você faria a consulta usando as informações recebidas
  }
 
}
 
//Instancia a classe
$model = new Model();
 
//Define parametros a serem passados
$options = array (
   'fields' => array ('*')
  ,'order'  => array ('nome ASC')
);
 
//Chama o método mágico
// Onde o primeiro parametro é o valor que o campo passado no nome do método deve ter.
$model->findByBlog('Technócio',$options);
 
/**
O que chega no método options é:
array(3) { 
    ["fields"] =>  array(1) { 
        [0]=>  string(1) "*" 
    } 
    ["order"] =>  array(1) { 
        [0]=>  string(8) "nome ASC" 
    } 
    ["conditions"] =>  array(1) { 
        ["blog"]=>  string(9) "Technócio" 
    } 
} 
**/
?>

O código ta bem comentado e bem simples também, embora não tenha me aprofundado muito no assunto acho que deu pra ter uma noção dessa possibilidade e do que pode ser feito com isso.

Como sempre, para dúvidas, sugestões e puxões de orelha, utilizem os comentários. Até a próxima (que dessa vez não vai ser tão demorada assim).

Quem utiliza o Fremwork CakePHP sabe que é uma mão na roda o route admin. Nos poupa um bocado de trabalho criar as funções da administração do site. Isso graças ao “Bake” Porém a rota não pode ficar totalmente acessivel a qualquer um, certo?

O Jonathan Snook escreveu um artigo em relação a isso, porém em alguns testes por aqui nenhum realmente funcionou utilizando .htaccess para proteção dessa rota com password.

Password Protecting Admin Functions in CakePHP.

O Conceito da proteção no artigo do Jonathan Snook é simples, E pode ser gerado com qualquer um que possua acesso ao SSH do site. Não é necessário acesso root para esses tipos de ações no servidor.
Seu servidor não te da acesso ao SSH? Está na hora de mudar para a IW²

O primeiro passo dessa proteção se dá ao inserir seguinte conteúdo no seu .htaccess :

1
2
3
4

AuthUserFile /diretorio/passwd/protecao
AuthName "Administracao CAKE"
AuthType Basic
Require valid-user

Com acesso ao ssh utilize o seguinte comando dentro da pasta “www”.

htpasswd -c /diretorio/passwd/protecao username

.
Isso gera um arquivo com a senha criptografada! Caso queira barar o arquivo gerado para verificar fiquem à vontade!

Bons testes, aqui nunca funcionou!

Meu jeitinho

A maneira no qual eu utilizo é a verificação simples de variavel, ou seja, apenas um usuário dentro do código no qual após o POST, verifica os dados, e grava uma sessão, se os mesmos forem iguais.

Primeiro passo é abrir o seu /app/config/routes.php, e crie uma rota chamada admin, usando o controller de páginas estáticas. Veja:

1

Router::connect('/admin/', array('controller' => 'pages', 'action' => 'display', 'admin'));

Agora crie um arquivo chamado admin.ctp dentro da pasta /app/views/pages/ com um formulário básico para login e senha:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

<?php  
//Define o layout padrão para a página
$this->layout = 'admin'; 
?>
<h1><?php __('Administração');?></h1>
<?php   
// Caso ocorra algum erro, é exibido em sua div correta!
if(isset($error)) {   
    echo "<div class='error'>" . $error . "</div>";   
}   
?>   
<?php 
/*
criamos um formulário com o vetor User, indicando a rota /admin/login, onde teremos nossa verificação de usuário e senha para registro da sessão da administração, e acesso ao restante dos actions _admin_
*/
echo $form->create('User', array('url'=>'/admin/login/'));
?>   
<fieldset>
    <legend>Digite os dados</legend>   
        <?php  echo $form->input('username', array('label'=>'Login')); ?>
        <?php echo $form->input('password', array('label'=>'Senha', 'id'=>'Senha')); ?>   
  <?php echo $form->end('Logar!'); ?>   
   </fieldset>
</form>

O próximo passo é criar uma nova rota no /app/config/routes.php, rota no qual foi definida na URL do nosso formulário, onde será submetida os dados para verificação.

1

Router::connect('/admin/login/', array('controller' => 'users', 'action' => 'admLogin'));

Claro, obviamente eu já possuo um controller chamado users, caso não tenha, pode cria-lo, utilizando o código abaixo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

<?php
class UsersController extends AppController {
 
	var $name = 'Users';
	var $helpers = array('Html', 'Form');
 
/*
Claro, que aqui irão outras actions suas ;)
*/
 
	function admLogin() {   
	    //verifica se o post possui alguma informação para registrar o nosso array com informações
	    if($this->data) {   
                $dbuser	=       array('username'=='Administrador', 'password'=>'Sua_senha_aqui');
	           if(($this->data['User']['username'] == $dbuser['username']) && 
                         ($this->data['User']['password'] == $dbuser['password']))  {   
                                 $this->Session->Write('admin', $dbuser);   
                                 // registra a sessão "admin" para futuras verificações
                                 $this->Session->setFlash('Logado com sucesso');   
                                 //Notifica o sucesso ao logar!
                                 $this->redirect('/admin/users/index');   
                                 // redireciona para a action index do controller users.
	        } else {   
	              $this->Session->setFlash('Erro! Dados inválidos');
                          // notifica o erro    
	        }   
	    }   
	}
 
 
}
?>

Note que por enquanto o nosso controller users possui apenas um action. Fica a seu critério a criação do resto do conteúdo ;)

Agora iremos criar a função para verificação da sessão:

1
2
3
4
5
6
7
8
9

<?php
	function checkAdminSession() {   
               if (!$this->Session->check('admin')) {   
               $this->Session->setFlash('Você não tem acesso a essa área');   
               $this->redirect('/admin/login/');   
    }   
}   
 
?>

A minha recomendação é que coloque essa função dentro do arquivo /app/app_controller.php no qual o cake carrega automáticamente. Esse arquivo serve para colocar as funções que vai utilizar em todos os controllers, sem a necessidade de ficar repetindo os mesmos.

Agora vem a parte mais interessante, vamos inserir o beforeFilter(); também dentro do /app/app_controller.php, para verificação do parametro /admin/ na url, e execução da verificação da sessão. Veja:

1
2
3
4
5
6
7
8

<?php
 
function beforeFilter() {   
        if(isset($this->params['admin'])) {   
           $this->checkAdminSession();   
    }   
 }
?>

O que a função faz é: Se existe algum parametro na url “admin”, executa a função checkAdminSession e veja se existe a sessão “admin”. Se não existir a sessão, a checkAdminSession redireciona para login.

Pronto, e assim você tem uma certa segurança em relação a rota /admin/ não estar sendo visualizada por tudo e por todos!

Esse primeiro encontro do grupo tem o objetivo e foco totalmente voltado para a tecnologia Zend Framework, decidido através de votação com direito a duas palestras totalmente direcionadas ao assunto.

Uma “pequena” surpresa: Reunimos (por enquanto) 4 ZCEs, simulado da php|architect para o exame de certificação. O simulado é bem próximo do exame de certificação real da Zend, e onde os ZCEs farão o simulado inteiro ao vivo: comentando questão por questão, citando as pegadinhas e os conhecimentos necessários para passar na certificação.

Quer tirar sua certificação Zend ? Essa palestra é para você!
Quer aprofundar seus conhecimentos sobre PHP ? É para você também!

Nosso número para participação do evento é bem limitado e só poderão entrar as pessoas que confirmaram a presença! Mas lembre-se, não esqueça de levar 1kg de alimento não perecível para ajudarmos instituições de caridades escolhidas por votação em nossa lista.

Programação

• 10:00h ~ 13:45h – Simulado da Certificação Zend
• 13:45h ~ 15:00h – Almoço
• 15:15h ~ 17:00h – Palestra Zend Framework

Local:

Burti Mooca ( Rua Dias Leme 130 – Moóca – São Paulo )

Valor:

1Kg de alimento não-perecível (ainda estamos definindo uma instituição a ser ajudada; se você quiser dar uma segestão, mande um comentário).

Ao vivo!

Você vai poder acompanhar a transmissão ao vivo do evento ou ler posteriormente o resumo das palestras e fazer download dos arquivos aqui no 15seg.com

Preparativos

Conseguimos algumas fotos dos preparativos…

Sei que muitos não são de São Paulo, cidade nem estado, porém não é por isso não podem ingressar e conhecer o Grupo PHPSP.

O Grupo PHP SP é uma iniciativa de organizar e abordar sobre a linguagem PHP, no estado de São Paulo. Se você não é do Estado de São Paulo, não tem problemas, pode ingressar no grupo sem problemas, mas se você é de São Paulo, e gostaria de participar de algo efetivo em favor do PHP, seja bem-vindo!

Está para acontecer o I Encontro PHP SP, no qual as vagas ja estão encerradas. O Valor da entrada é 1 kilo de alimento, no qual vai ser doado para uma instituição de caridade, que ainda não foi escolhida! Tem uma sugestão? Mande nos comentários desse post, ou no site do php sp.

Eu indiquei a Fundação André Luiz, no qual a entidade atende e dá abrigo aos portadores de deficiências especiais. Possui um âmbito da Atuação Federal e existe a 50 anos!

O Conteúdo do encontro que irá ocorrer no dia 7 de Fevereiro, ja tem agenda pronta:

• 10h ~ 13:45h – Simulado da Certificação Zend
• 13:45h ~ 15h – Almoço
• 15:15h ~ 17:00h – Palestra Zend Framework

O Evento será realizado na Burti em Mooca, Rua Dias Leme, 130. Caso queira viualizar o mapa clique aqui.

O Conteúdo dos slides, e fotos, e o que mais for gravado será reproduzido pelo grupo e por mim, que estarei lá. ;)

Logo após o encontro, teremos o PHPinga, que é o encontro para sair da formalidade, e iremos a um bar próximo, nos divertir! Esse é livre, e estão todos convidados!

Grande Abraço

Dois malucos conversam sobre php via gtalk e um deles fala, “o vagabundo, to precisando de gente pra escrever num blog comigo, ta afim?”… é meus caros, foi assim que nasceu o Technócil, que é uma mistura das palavras tecnologia e imbecil (algo que combina bem com a nossa personalidade).

Os dois de quem vós falo são Tobias (Buda) e João Vagner (Girafa) dois nerds programadores que iniciaram a carreira com PHP, mas que depois foram passando por vários outros caminhos obscuros. Depois dessa descrição da pra perceber que o Technócil se propõe a ser um blog de tecnológia e afins, mas sempre vagabundo preguiçoso bem humorado, e assim começamos mais uma quest tragetória, falando bobagem o que pensamos e compartilhando nerdisses conhecimentos.

3… 2… 1… Round 1… FIGHT!