Primeiro, eu baixei um script que a própria FreeNode.org disponibiliza para o irssi, o instalei e depois algumas dependências.

cd ~/.irssi/scripts/autorun #Se o diretório não existir, crie-o
wget http://www.freenode.net/sasl/cap_sasl.pl

Como maioria das dependências não estavam nos repositórios oficiais do Arch Linux nem do AUR, eu tive que as instalar separadamente e ai já aproveitei pra fazer um script de instalação com todas as dependências. Esse script funciona em qualquer distro. São necessários os seguintes módulos: Math::BigInt, Math::BigInt::FastCalc, Math::BigInt::GMP, Math::BigInt::Pari, Crypt::DH e Crypt::OpenSSL::BigNum.

Abra um novo arquivo e cole as linhas abaixo, será nosso script de instalação.

#!/bin/bash
 
packages=(Math-BigInt-1.89 Math-BigInt-FastCalc-0.19 Math-BigInt-GMP-1.24 Math-BigInt-Pari-1.13 Crypt-DH-0.06 Crypt-OpenSSL-Bignum-0.04)
 
mkdir /tmp/cpan-comp
cd /tmp/cpan-comp
wget http://www.cpan.org/authors/id/T/TE/TELS/math/Math-BigInt-1.89.tar.gz
wget http://www.cpan.org/authors/id/T/TE/TELS/math/Math-BigInt-FastCalc-0.19.tar.gz
wget http://www.cpan.org/authors/id/T/TE/TELS/math/Math-BigInt-GMP-1.24.tar.gz
wget http://www.cpan.org/authors/id/T/TE/TELS/math/Math-BigInt-Pari-1.13.tar.gz
wget http://www.cpan.org/authors/id/B/BT/BTROTT/Crypt-DH-0.06.tar.gz
wget http://www.cpan.org/authors/id/I/IR/IROBERTS/Crypt-OpenSSL-Bignum-0.04.tar.gz
 
for pkg in $packages; do
	tar -xzvf "$pkg.tar.gz" ;
	cd "$pkg" ;
	perl Makefile.PL ;
	make && make test && sudo make install ;
	cd .. ;
done;

OK, o garotosopa tirou toda a graça do meu script, me alertando uma coisa da qual não sabia, para instalar um módulo do perl, basta digitar:

cpan -i Math::BigInt Math::BigInt::FastCalc Math::BigInt::GMP Math::BigInt::Pari Crypt::DH Crypt::OpenSSL::Bignum

Inicie o irssi e digite:

/sasl set freenode Seu_nick Sua_Senha BH-BLOWFISH
/sasl save
/save
/quit

Agora, é só ajeitar o config do irssi.

vim ~/.irssi/config

servers = {
	{
		address = "irc.freenode.org";
		chatnet = "freenode";
		port = "7000";
		use_ssl = "yes";
		ssl_verify = "yes";
		ssl_capath = "/etc/ssl/certs";
	}
}

Entre no irssi novamente e pronto! Só usar o /connect freenode !

E ai, gostou?

Eu já tinha lido sobre uma opção do Vim chamada keywordprg, mas nunca havia encontrado uma serventia. Quando eu li no blog do bjori, realmente me veio à mente como eu poderia utilizá-la.

Eu instalei a última versão do pear aqui, e executei os comandos que ele cita no blog:

pear install doc.php.net/pman

Eu precisei aumentar a memória do php.ini (memory_limit), 32M não foi o suficiente.

O manual será instalado no diretório especificado em “doc_dir” da configuração da pear e o executável no “bin_dir“. Para verificar as configurações atuais:

pear config-show # Mostra todas as configurações atuais
pear config-get bin_dir # Mostra configuração atual da opção bin_dir
pear config-get doc_dir # Mostra configuração atual da opção doc_dir
# Para modificar:
pear config-set bin_dir /outro/bin
pear config-set doc_dir /outro/docs

Depois de instalado, você pode utilizar ele tanto no Vim quanto fora do Vim:

pman array_merge

Bom, se lembra que eu havia falado sobre o keywordprg ? Assim como o makeprg é o programa executado ao se executa :make no Vim e o grepprg o comando executado ao se executar :[grep|vimgrep], o keywordprg é executado quando se preciona K (k maiúsculo) sobre alguma palavra chave – que no nosso caso será uma função php.

O artigo citado ali em cima, indica para colocarmos no .vimrc, mas eu acho mais interessante por no .ftplugin/php.vim (se o arquivo não existir, crie). Assim, só será carregado caso o tipo do arquivo for php, possibilitando utilizar outros programas para outras linguagens

" Programa executado quando pressionado K
set keywordprg=pman

Agora faça o teste: abra um arquivo php, coloque o cursor sobre alguma função e pressione K. Para fechar o manual aberto, basta precionar q. Pode-se utilizar a busca com /termo e também navegar nos resultados com n/N. j/k/UP/DOWN movem o arquivo para cima e para baixo, normalmente, como se fosse um manpage.

Eai, este post ajudou em algo?

Expressões Regulares

Expressão regular é uma ferramenta muito forte para o tratamento de texto. É muito utilizado para substituições ou para verificar integridade dos dados, pois, através da expressão regular, vulga regex ou re, pode-se casar padrões de texto. Por exemplo:

/^[a-zA-Z0-9]+$/
Para somente caracteres alfanuméricos.
 
/^(\d{3}\.){2}\d{3}-\d{2}$/
Validando formato de CPF.

Esse tipo de regex é simples, valida praticamente só os caracteres que compõe uma dada string. Porém, as Perl Compatible Regular Expressions (Expressões Regulares Compatíveis com Perl), também conhecidas como pcre, permitem muito mais, inclusive utilizar condicionados (if’s), porém isso é para outro post! O que vamos falar agora é de Lookahead e Lookbehind.

Lookahead

Lookahead é uma forma de casar strings que tenham ou não um determinado final. É utilizado (?⁼…) para o positivo, ou seja, que terminem com; e (?!…) para o negativo, ou seja, que não termina com.

Um exemplo simples, seria a busca, primeiramente, de Gustavo seguido por Dutra. Se existisse Gustavo ou Gustavo Outracoisa, ele não casaria. Ao contrário, o segundo exemplo somente casaria o Gustavo ou o Gustavo Outracoisa, porém não casaria o Gustavo Dutra:

/Gustavo(?= Dutra)/
/Gustavo(?! Dutra)

Vamos ver um exemplo mais funcional e complexo em python:

import re
print re.findall(r'\s?([^;]+);', 'Vim Editor; GVim Editor; Firefox Browser; Emacs Editor; Thunderbird Email;')
# output seria:
['Vim Editor', 'GVim Editor', 'Firefox Browser', 'Emacs Editor', 'Thunderbird Email']

Mas e se quisesse somente os editores da lista?

import re
print re.findall(r'\s?([^;]+ Editor);', 'Vim Editor; GVim Editor; Firefox Browser; Emacs Editor; Thunderbird Email;')
# output seria:
['Vim Editor', 'GVim Editor', 'Emacs Editor']

Mas e se eu quisesse todos MENOS os editores? É ai que entra o Lookahead, vamos pegar todos que não terminam com Editor.

import re
re.findall(r'\s?([^;]+ (?!Editor))', 'Vim Editor; GVim Editor; Firefox Browser; Emacs Editor; Thunderbird Email;')
# output seria:
['Firefox ', 'Thunderbird ']

Observem que o que casar com (?!Editor) não entra no resultado, para incluí-lo, seria necessário uma expressão regular um pouco mais complexa utilizando condicionais. Veremos isso depois!

Lookbehind

Lookbehind faz o mesmo que o lookahead, porém, como o próprio nome diz, não procura depois, mas sim antes, da string dita. (?<=…) para o positivo e (?<!…) para o negativo.

Vamos pegar um RT de um tweet do twitter.com. Como gosto de ser eclético, vou usar perl:

print "RT \@gustavotkg Testando ERs." =~ /(?< =@)gustavotkg/
# Output seria:
1

Essa expressão retorna 1 (ou seja, TRUE), caso exista algum gustavotkg precedido por uma @.

OBS: @ são escapadas porque representam variáveis do tipo array em perl.

print "Este é um RT \@gustavotkg Testando ERs." =~ /(?< !RT )\@gustavotkg/
# Output seria, vazio, pois o @gustavotkg é precedido por um RT
 
print "RT \@gustavotkg2 também estou testando ERs." =~ /(?<!^RT \@gustavotkg\b)(.+)$/
# Output seria:
RT @gustavotkg2 também estou testando ERs.

O \b significa borda de palavra (espaço, ponto final, exclamação, final de linha, etc). Como 2 não é uma borda de palavra, pois a expressão regular diz o seguinte: "Case com tudo que não começar com RT @gustavotkg seguido de uma borda de palavra".

Condicionais

Como se pode notar nos casos acima, os operadores de lookahead e lookbehind não colocam o valor casado junto ao resultado final. Para isso temos que verificar condicionalmente e adicionar manualmente o valor. A sintaxe é esta: (?(condicao)(caso verdadeiro)|(caso falso)).

Parece complicado, mas é bem simples, vamos começar com algo fácil utilizando php:

preg_match("/(?(?< =@)\w+|\w{2})/", "@testando", $r);
var_dump($r);
# Output seria:
array(1) {
  [0]=> string(8) "testando"
}
 
preg_match("/(?(?< =@)\w+|\w{2})/", "testando", $r);
var_dump($r);
# Output seria:
array(1) {
  [0]=> string(8) "te"
}

Notem o condicional: Se começar (lookbehind) com @, então quero que case toda a palavra que segue o @, caso contrário, quero apenas os dois primeiros caracteres. Fácil? Vamos complicar!

Lembra do exemplo mais acima do lookahead? Vou refrescar a memória:

import re
re.findall(r'\s?([^;]+ (?!Editor))', 'Vim Editor; GVim Editor; Firefox Browser; Emacs Editor; Thunderbird Email;')
# output seria:
['Firefox ', 'Thunderbird ']

Notem que ela não adicionar a categoria do Firefox nem do Thunderbird, pois o (?!) como supracitado, não é colocado junto no resultado final. Para adicioná-los, podemos usar o condicional.

preg_match_all("/(\w+ (?(?!Editor)\w+));/","Vim Editor; GVim Editor; Firefox Browser; Emacs Editor; Thunderbird Email;",$e);
var_dump($e);
// Output seria:
array(2) {
  [0]=>
  array(2) {
    [0]=>
    string(16) "Firefox Browser;"
    [1]=>
    string(18) "Thunderbird Email;"
  }
  [1]=>
  array(2) {
    [0]=>
    string(15) "Firefox Browser"
    [1]=>
    string(17) "Thunderbird Email"
  }
}

Ou seja, no segundo índice do array, que na verdade é o indice 1, consta o resultado pego. Veja que utilizamos o seguinte método: Se \w+ não for seguido de 'Editor' então pega o \w+, senão ignora pois não é para casar. Assim, se for Editor, ele nunca irá casar.

Dúvidas? Sugestões? Deixe um comentário!

Controle de Versão

• SVN Cheat Sheet
• Git Cheat Sheet
• Mercurial Cheat Sheet
• Bazaar Cheat Sheet

Frameworks

• Prototype Cheat Sheet
• MooTools Cheat Sheet
• jQuery Cheat Sheet
• Ruby On Rails
• Django Cheat Sheet
• CodeIgniter Cheat Sheet
• CakePHP Cheat Sheet
• Mais de 12 Symfony Cheat Sheets

Programação

• Bash Script Quick Refences
• AWK Cheat Sheet
• HTML5 Canvas Cheat Sheet
• PHP Cheat Sheet
• Ruby Quick Refence
• 9 Perl Cheat Sheets
• Python Quick Refence
• Regular Expression Cheat Sheet

Web Design

• Font Size Cheat Sheet
• Propriedades CSS
• HTML Char Entities Cheat Sheet
• 6 Design Colors Cheat Sheet
• SEO Web Developer Cheat Sheet

Bancos de Dados

• XML Schema Structure Quick Refence
• MySQL Cheat Sheet
• PostgreSQL Cheat Sheet

Ferramentas

• Google Search Cheat Sheet
• Firebug Cheat Sheet
• Vimperator Cheat Sheet
• LaTeX Cheat Sheet
• Vim Cheat Sheet
• Vim Quick Refence
• mod_rewirte Cheat Sheet

Alguma que eu tenha esquecido? Posta ae nos comentários!

Veja a Galeria Demo E o arquivo css comentado.

Ai me lembrei do vídeo Hitler falando sobre o Internet Explorer 6:

Como indagou o filme, será que um dia poderemos utilizar todo o potencial do CSS3?

Depois de atualizado o pacote exaile do ArchLinux, o plugin XKeys parou de funcionar e não aceitava mais minhas teclas de atalho do teclado para manipular áudio, como forward, backward, stop, play, etc.

Esse problema era antigo, ele acusava que era necessário a lib mmkeys.so e que não estava presente. Nunca tinha tempo pra verificar o problema, até que eu decidi ir atrás.

Configurando as teclas

O objetivo do post é solucionar o problema, mas para não ficar descontextualizado, vou mostrar como mapear as teclas. É fácil e biodegradável, não polui o meio ambiente.

xev | grep keycode

Vão vir linhas confusas a cada tecla pressionada. O importante é o número junto o “keycode“. Pegue o número da respectiva tecla e escreva em ~/.Xmodmap:

keycode NUMERO = XF86AudioLowerVolume
keycode NUMERO = XF86AudioMedia
keycode NUMERO = XF86AudioMute
keycode NUMERO = XF86AudioNext
keycode NUMERO = XF86AudioPlay
keycode NUMERO = XF86AudioPrev

Substitua o NUMERO pelo número do keycode que você detectou com o xev, acho que está claro o que cada um representa, né? Abra o arquivo ~/.xinitrc e adicione

xmodmap ~/.Xmodmap

Se você tiver preguiça de reiniciar a interface gráfica, pode digitar o comando acima para fazer as teclas funcionarem. Ai é só habilitar no exaile!!!

Ajustando o Exaile

pacman -Ql exaile | grep mmkeys

Identifiquei que a mmkeys.so realmente não constava nos arquivos de instalação do exaile. Como o pacman guarda um cache das versões dos programas que eu instalei e atualizei, fui verificando os arquivos de cada uma delas atrás dessa lib, pois um dia isso havia funcionado.

pacman -Qpl /var/cache/pacman/pkg/exaile-0.2.14-2.pkg.tar.gz | grep mmkeys

Esta foi a última versão que tem a dita lib (exaile /usr/lib/exaile/mmkeys.so) – aparentemente o problema veio da versão 3 em diante -, então bastou eu jogá-la para /usr/lib/exaile.

mkdir /tmp/exaile-src
tar -xzvf /var/cache/pacman/pkg/exaile-0.2.14-2.pkg.tar.gz -C /tmp/exaile-src
sudo mv /tmp/exaile-src/usr/lib/exaile/mmkeys.so /usr/lib/exaile/mmkeys.so
rm -r /tmp/exaile-src

Pronto! Não precisa nem reiniciar o exaile, apenas habilitar o plugin XKeys que ele irá reconhecer automaticamente as suas teclas de atalhos.

Não fui atrás para saber se é problema no empacotamento ou o quê, mas deve funcionar isto até sair uma outra solução.

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!!!

• 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>

Exemplo de uso do vimgrep

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!

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

• 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.

Referências

• Linux.com
• Jason Haruska