Tchelinux 2009 – Porto Alegre
12 de Novembro de 2009, 0:00 - sem comentários aindaPara quem é do Sul, estarei em Porto Alegre no dia 14/11/2009 ministrando duas palestras no evento Tchelinux. A programação tem mais de 60 palestras sobre diversos temas e a entrada é apenas 2kg de alimentos não perecíveis. Aqueles que participarem recebem um atestado de 10h para usar como atividade complementar.
Para mais informações http://www.tchelinux.org/2009. As palestras serão:
VIM-de a mim, produtividade
Uma palestra que mostra maneiras para um edição de texto efetiva e rápida usando o vim.
jQuery – Introdução
Apresenta o porquê do jQuery ser um excelente framework para desenvolvimento rápido com javascript.
Se alguém tiver assistido a alguma palestra, favor dar um feedback!!!
Tchelinux 2009 – Porto Alegre
12 de Novembro de 2009, 0:00 - sem comentários aindaPara quem é do Sul, estarei em Porto Alegre no dia 14/11/2009 ministrando duas palestras no evento Tchelinux. A programação tem mais de 60 palestras sobre diversos temas e a entrada é apenas 2kg de alimentos não perecíveis. Aqueles que participarem recebem um atestado de 10h para usar como atividade complementar.
Para mais informações http://www.tchelinux.org/2009. As palestras serão:
VIM-de a mim, produtividade
Uma palestra que mostra maneiras para um edição de texto efetiva e rápida usando o vim.
jQuery – Introdução
Apresenta o porquê do jQuery ser um excelente framework para desenvolvimento rápido com javascript.
Se alguém tiver assistido a alguma palestra, favor dar um feedback!!!
Buscas eficientes no Vim com vimgrep
2 de Novembro de 2009, 0:00 - sem comentários aindaA busca efetiva pode ajudar muito, caso bem usada, tanto no ganho de tempo como na efeciência de substituições ou refactories. Seguem alguns outros exemplos de finalidades para a busca utilizando o Vim:
- Certeza de encontrar todas as incidências
- Ficam visualmente destacadas (com :set hlsearch)
- Testar substituições
- Verificar a ortografia atrás de erros de digitação
- Encontrar variáveis ou funções não utilizadas, só declaradas
- Encontrar rapidamente algum termo
- Verificar a existência de algum termo
Além da conhecida / (barra) para buscar, existe o :vimgrep. É dele que quero falar.
Vimgrep
Comando
:vim[grep][!] /{pattern}/[g][j] {files}
- Busca inscidências de pattern nos files listados.
- pattern pode ser uma expressão regular ou não
- A exclamação (!) ignora as alterações já feita no arquivo atual
- g procura por todas as inscidências, não só a primeira, em cada arquivo
- j pula para o primeiro resultado ao executar o comando
- files podem conter wildcards, como *, ? e **
- Os resultados são abertos na quickfix list
Exemplos
:vimgrep! /$var/ arquivo.pl
Pesquisa pela primeira inscidência de $var no arquivo.pl
:vimgrep /texto/ *.rb
Busca por texto em todos os arquivos com a extensão .rb do diretório atual (para descobrir qual o diretório atual, use :pwd. Para mudar :cd dir)
:vimgrep /TeXtO/ *.py dir/*.py
Busca com case-sensitive em todos os arquivos .py do diretório atual e dos dentro do diretório dir/.
:vimgrep /minhaFuncao/g **/*.c
Busca recursiva dentro da árvore de diretórios do diretório atual cuja extensão seja .c
:vimgrep /< \([^ ]\+\)[^>]*>.\+< \/\1>/ index.html
Busca usando expressões regulares também são permitidas!
Navegando na QuickFix List
- :copen
- :cfirst
- :cprevious
- :cnext
- :clast
- :cclose
Como nosso foco é a eficiência, podemos criar mapeamentos para andar pela quickfix list!
map <F9> :copen<CR> map <F10> :cclose<CR> map <A-j> :cnext<CR> map <A-k> :cprevious<CR>
Conclusão
Esse recurso não parece ser muito abordado por ai, mas é extremamente importante. Seja criativo e descubra onde melhor usar o :vimgrep! Tenho certeza de que vai lhe ajudar! E quando encontrar, comente ai!
Facade Pattern com perl orientado a objetos
17 de Outubro de 2009, 0:00 - Um comentárioOlá! Faz um tempo que não mexo com perl. Encontrei perdido um arquivo com esse exemplo que fiz em 2008, segundo a data de última modificação. Então, decidi dar continuidade aos posts de design patterns. Esse padrão é bem interessante, poderia ser traduzido para Fachada.
Eu gosto dessa tradução, porque traduz bem direitinho o que ele representa, é uma fachada para “esconder” chamadas de vários métodos de objetos diferentes atrás de um mesmo método. Pense assim:
Toda vez que eu aperto o botão de uma máquina de café e pedir um mocacchino, acontece a mesma coisa:
- Moe-se o café
- Pega-se um copo
- Esquenta-se a água
- Passa-se o café
- Coloca-se o café passado no copo
- Coloca-se o chocolate
- Coloca-se o leite
- Apita pra dizer que está pronto
Se olharmos isso com a visão de um pojetista, vemos que temos várias responsabilidades e que não podemos deixar tudo numa mesma classe, como por exemplo:
- Responsável por moer o café
- Responsável por colocar algo no copo
- Responsável por pegar 1 copo novo
- Responsabilidade de saber quanto de cada ingrediente por no copo
- Responsabilidade de apitar e escrever nos leds
Enfim, para que o código seja organizado, precisamos distribuir as responsabilidades de acordo com as necessidades e obrigações de cada classe. Porém, cada vez que o botão for pressionado, seria muito cruel ter que chamar várias classes e executar esses métodos que selecionam o copo, moem o grão, etc.
Para esses casos foi pensando o Facade Pattern, ou seja, a Fachada. Todo aquele algoritmo descrito na primeira lista acima, é encapsulado dentro de uma classe específica para a máquina de café, dentro do método pressionaBotao, por exemplo. Chamando o método, ele se encarrega de interagir com os objetos de seleção do copo, do cálculo da quantidade de ingredientes, etc.
Fiz um exemplo em perl, pensando num cinema. Acredito que fique fácil entender a partir dele. Seguem as classes utilizadas:
#!/usr/bin/perl -w { # Classe representando o amplificador package Amplifier; # construtor sub new { my $class = shift; $class = ref($class) || $class; my $this = {}; bless($this, $class); return $this; } # liga o amplificador sub on { my $this = shift; print "Turning the Amplifier [ON]\n"; } # desliga o amplificador sub off { my $this = shift; print "Turning the Amplifier [OFF]\n"; } # Muda o volume sub setVolume { my $this = shift; $volume = shift; print printf "Turning the Amplifiers volume to %d%%\n", $volume; } # coloca no mudo sub mute { my $this = shift; $this->setVolume(0); } } { # Classe representado o aparelho de DVD package Dvd; # construtor sub new { my $class = shift; $class = ref($class) || $class; my $this = {}; $this->{state} = 'stop'; $this->{movie} = undef; bless($this, $class); return $this; } # liga o dvd sub on { my $this = shift; print "Turning the DVD Player [ON]\n"; } # desliga o dvd sub off { my $this = shift; print "Turning the DVD Player [OFF]\n"; } # da play no filme sub play { my $this = shift; $movie = shift; if ($this->{state} eq 'play') { $this->{stop}(); $this->{play}($movie); } else { $this->{movie} = $movie; $this->{state} = 'play'; print printf "Playing the movie %s\n", $movie } } # da stop no filme sub stop { my $this = shift; if ($this->{state} eq 'play') { $this->{state} = 'stop'; print printf "Stoping the movie %s\n", $this->{movie}; $this->{movie} = undef; } } # ejeta a bandeja pra por no dvd sub eject { my $this = shift; if ($this->{state} eq 'play') { $this->{stop}(); } print "Ejecting the DVD\n"; } } { # classe representando o projetor package Projector; # construtor sub new { my $class = shift; $class = ref($class) || $class; my $this = {}; bless($this, $class); return $this; } # ajusta o canal de vídeo sub videoChannel { my $this = shift; print "Setting Video Channel\n"; } # liga o projetor sub on { my $this = shift; print "Turning the Project [ON]\n"; } # desliga o projetor sub off { my $this = shift; print "Turning the Project [OFF]\n"; } } { # Classe representando as luzes do cinema package Lights; # construtor sub new { my $class = shift; $class = ref($class) || $class; my $this = {}; $this->{state} = 'off'; bless($this, $class); return $this; } # liga as lâmpadas sub on { my $this = shift; if ($this->{state} eq 'off') { print "Turning the Lights [ON]\n"; $this->{state} = 'on'; } } # desliga as lâmpadas sub off { my $this = shift; if ($this->{state} eq 'on') { $this->{state} = 'off'; print "Turning the Lights [OFF]\n"; } } } { # classe representando uma máquina de pipoca package PopcornMachine; # construtor sub new { my $this = {}; my $class = shift; $class = ref($class) || $class; $this->{state} = 'off'; bless($this, $class); return $this; } # liga a máquina sub on { my $this = shift; if ($this->{state} eq 'off') { $this->{state} = 'on'; print "Turning the Popcorn Machine [ON]\n"; } } # estoura as pipocas sub pop { my $this = shift; if ($this->{state} eq 'on') { print "Poping the corns ;P\n"; } } # desliga a máquina sub off { my $this = shift; if ($this->{state} eq 'on') { $this->{state} = 'off'; print "Turning the Popcorn Machine [OFF]\n"; } } }
A orientação a objetos no perl é meio sinistra. Existem diversas formas de se programar orientado a objetos no perl, eu escolhi esta pois parece mais simples e fácil. Bom, essas são as classes utilizadas:
- Amplifier
- DVD
- Projector
- Lights
- PopcornMachine
Bom, cada vez que um filme inicia ou termina no cinema, várias operações são repetidas sempre. Alguém já viu cinema com as luzes acesas? Bem, sempre se desliga as luzes. Então observe a classe abaixo que representa o Facade.
{ # classe representando o cinema package CineFacade; # construtor sub new { my $this = {}; my $class = shift; $class = ref($class) || $class; $this->{amplifier} = shift || undef; $this->{dvd} = shift || undef; $this->{projector} = shift || undef; $this->{lights} = shift || undef; $this->{popcornMachine} = shift || undef; bless ($this, $class); return $this; } # começa a ver o filme sub watchMovie { my $this = shift; $movie = shift; # Popcorn machine $this->{popcornMachine}->on(); $this->{popcornMachine}->pop(); # Home lights $this->{lights}->off(); # Projector $this->{projector}->on(); $this->{projector}->videoChannel(); # Amplifier $this->{amplifier}->on(); $this->{amplifier}->setVolume(100); # DVD $this->{dvd}->on(); $this->{dvd}->play($movie); } # termina de ver o filme sub endMovie { my $this = shift; $this->{popcornMachine}->off(); $this->{lights}->on(); $this->{projector}->off(); $this->{amplifier}->off(); $this->{dvd}->stop(); $this->{dvd}->eject(); $this->{dvd}->off(); } }
Observem o método watchMovie e endMovie. Eles chamam operações comum a todas as seções do cinema.
Aqui vai o exemplo de uso do facade no meio da aplicação:
{ # Exemplo de uso $cine = CineFacade->new( Amplifier->new(), Dvd->new(), Projector->new(), Lights->new(), PopcornMachine->new() ); print "Movie Session started: \n\n"; $cine->watchMovie('Titanic'); print "Movie Session ended: \n\n"; $cine->endMovie(); }
O output é mais ou menos assim:
Movie Session started: Turning the Popcorn Machine [ON] Poping the corns ;P Turning the Project [ON] Setting Video Channel Turning the Amplifier [ON] Turning the Amplifiers volume to 100% Turning the DVD Player [ON] Playing the movie Titanic Movie Session ended: Turning the Popcorn Machine [OFF] Turning the Lights [ON] Turning the Project [OFF] Turning the Amplifier [OFF] Stoping the movie Titanic Ejecting the DVD
Usando Screen e Vim para Pair Programming remoto
10 de Outubro de 2009, 0:00 - sem comentários aindaBem, é notável o crescimento das metodologias ágeis de desenvolvimento de software. Uma das práticas que me agrada muito, é a programação em pares (pair programming). É bem perceptível, a um longo prazo, a diferença que faz essa prática. Navegando pela internet, como um marujo sem rumo, encontrei um post falando sobre Remote Pair Programming. Parece meio estranho, porque o XP (eXtreme Programming) faz alusão a uma dupla programar em um único computador, com um único teclado e um único mouse.
Então, vamos tentar simular este ambiente utilizando 4 ferramentas simples:
- screen
- ssh
- vim
- skype
Destas, só o skype não é open-source. Mas é interessante manter uma conversa verbal, pois conversas escritas podem desviar o foco da programação, que é bem mais rápida e precisa do que a escrita, que pode deixar brechas para má interpretações. A conversa verbal consegue interromper o programador ao mesmo tempo em que escreve, corrigindo-o ou questionando-o.
Conectados no skype, basta decidir em qual máquina será o desenvolvimento. Esta, por sua vez, terá que ter um servidor ssh. Ela será o host da programação. Será necessário, também, nesta máquina, ter instalado o screen, que é um programa que possibilita criar ’sessões’ no terminal.
Host
screen -S PairProgramming
Parece que nada mudou, mas você está numa sessão do screen chamada PairProgramming.
Precione CTRL+a e digite:
:multiuser on
Pressione CTRL+a novamente e digite:
:acladd usuarioclient
Tudo que você ver nesta sessão, será visto pelo outro usuário (usuarioclient) que se conectará nela.
Então, abra o vim, pois será necessário um edito de textos de verdade , e se divirta:
vim /caminho/arquivo
Client
ssh usuarioclient@host screen -x usuariohost/PairProgramming
Pronto! Agora você está acessando a mesma seção! Tudo que o usuáriohost fizer, o usuárioclient enxergará e vice-versa.
Agora, basta descutir a tarefa via Skype e programar. As atualizações são em tempo real, ou seja, aparecem ao mesmo tempo que são escritos, digo… depende da conexão, mas não é um grande problema.
Caso seja necessário que o usuarioclient não possa modificar o código, apenas assitir e dar pitacos, o usuáriohost deve pressionar CTRL+A e digitar:
:aclchg usuarioclient -w #
Eu ainda vou programar assim, depois digo a experiência.