Bastos

Aqui estão os slides e os exemplos de código da minha palestra que coloquei lá no Github.

O evento Ceará On Rails foi excelente, um ótimo inicio para a comunidade Rails e Ruby do Ceará! As fotos estão aqui.

O evento teve três palestras, a minha sobre alguns recursos avançados de Ruby, o que talvez tenha sido não um bom tema para um primeiro encontro :D. A palestra do Coutinho foi sobre o ActiveRecord na visão de um DBA, ótimo para tirar o medo dos puristas. A palestra do Akita foi sensacional, o japinha parece uma metralhadora! Então, tomara que que 20% dos que estavam ali saiam da média.

Foram quase 100 pessoas (vieram 2 caras da Bahia!), muita gente para um primeiro evento regional! Fiquei muito satisfeito, parabéns a todos que organizaram, ajudaram e foram lá conferir o primeiro Ceará On Rails.

Próximo ano a nossa meta é um dia inteiro de muito Ruby, de muito Rails e de muitas outras coisas legais! Acompanhem a comunidade.

Bem, eu nas minhas noites de programador que não dorme e de palestrante que ainda não tem slides feitos criei o Gary, uma DSL feita em cima do Markaby para criar apresentações, ainda não tem algumas features que gostaria mas depois do Ceará On Rails devo ir colocando.

Depois de muito discutir com um colega sobre os blocos e closures, ele falava que nem tudo em ruby era OO, eu falava que tudo era. Isso era mais confuso que eu esperava.

Bem, em Smalltalk blocos são objetos por si só, em Ruby não, eles são estruturas da linguagem. Mas ai você fala, “se eu passar um bloco por parâmetro e der um .class nele, vai aparecer que ele é um Proc”, de fato, Ruby faz a conversão de bloco para Proc automaticamente, mágica, você ainda pode usar o Proc.new ou o lambda para fazer isso, então seu bloco vira uma closure.

# Percebam o & que admite o método receber um bloco e dentro ser usado como uma closure.
def x(&block)
  puts block.class
end

Blocos foram criados inicialmente para loops executarem com yield, mas depois como o próprio Matz explica, foi sendo usado para tudo, então, o que usando são sim objetos.

“…A closure is a nameless function the way it is done in Lisp. You can pass around a nameless function object, the closure, to another method to customize the bhttp://www.nabble.com/Yield-should-be-renamed-call_block-to11494240.html#a11494557ehavior of the method. As another example, if you have a sort method to sort an array or list, you can pass a block to define how to compare the elements. This is not iteration. This is not a loop. But it is using blocks… “

Apesar do Matz falar como se closure fosse diferente de blocos, há quem chame o bloco de closure, como o Martin Fowler:

“I use closures a lot in Ruby, but I don’t tend to create Procs and pass them around.”

Ele não precisa criar os procs, é claro, Ruby faz isso para você!

“…The second difference is less of a defined formal difference, but is just as important, if not more so in practice. Languages that support closures allow you to define them with very little syntax…” - Martin Fowler

Tudo bem, mas ai lendo mais eu chego a isso:

“The each method takes a one argument block (Ruby and Smalltalk both refer to closures as blocks).”

Hum, mas não foi isso que eu entendi lendo o que o Matz falou:

Bill Venners: What makes a block a closure?

Yukihiro Matsumoto: A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Evenhttp://www.martinfowler.com/bliki/Closure.html after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it’s garbage collected, and the local variables go away.

Mas ai eu encontro isso que esclarece bastante sobre Procs e blocos:

“Proc objects are blocks of code that have been bound to a set of local variables. Once bound, the code may be called in different contexts and still access those variables.”

- Retirado da documentação do Ruby

Portanto, uma coisa é um bloco (função anônima), outra coisa é uma closure (objeto que contem uma função anônima, um estado e escopo), a conversão no Ruby é automática quando ele é atribuído a alguma variável. Bloco é uma construção sintática realmente interessante, podem não ser objetos, mas isso pouco me importa…

Mais em:
http://www.ddj.com/architect/184404436
http://rubylearning.com/blog/2007/11/30/akitaonrails-on-anatomy-of-ruby-blocksclosures/
http://www.ruby-lang.org/en/about/
http://www.sapphiresteel.com/Ruby-The-Smalltalk-Way-3-The-World
http://www.ruby-forum.com/topic/71221
http://www.neeraj.name/blog/articles/589
http://deadprogrammersociety.blogspot.com/2007/02/ruby-blocks-closures-and-continuations.html
http://www.rubyist.net/~matz/slides/oscon2005/mgp00001.html
http://www.infoq.com/news/2008/01/new-lambda-syntax
http://www.martinfowler.com/bliki/Closure.html
http://www.akitaonrails.com/2007/11/30/anatomia-de-ruby-blocks-closures
http://www.nabble.com/Yield-should-be-renamed-call_block-to11494240.html#a11494557

obs: Estou com muito sono, provavelmente algo tenha passado desapercebido

É engraçado como a vida da voltas, sempre achei o Emacs um editor meio maluco, esquisito e feio! Eu só não entendia ele. Passei boa parte do tempo programando em editores como Gedit, Notepad++ ou até mesmo, Netbeans (Esse foi por pouco tempo) até ver na tela de um colega do trabalho o Emacs aberto, e ouvir ele falar as vantagens de usar.

Certo, então instalei, pacman -S emacs-cvs, não larguei, passei um tempo me acostumando, montando meu .emacs e hoje me sinto muito confortável usando Emacs. O fato de poder modificá-lo como quiser, sim, como quiser, é extremamente interessante. O Emacs é um editor antigão, por isso tem muita coisa já escrita nele, tem muita coisa boa e claro, tem seus defeitos, mas no geral, me acostumei muito bem. Ele é extensível pois foi feito basicamente em cima de um core pequeno escrito em C e o resto TODO em Lisp (Emacs Lisp).

Bem, vale a pena tentar para aqueles que como eu, achava que o Emacs era uma grande “coisa”, e não um grande editor.

Apenas um hack para mostrar como Ruby é legal!

Tem uma biblioteca legal também chamada Functor: http://github.com/dyoder/functor.

Claro que se você, assim como eu, gosta mesmo desse tipo de feature, busque mais sobre Erlang ou Haskell.

Estou lendo o Programming Erlang, sempre tive vontade de aprender uma linguagem funcional e Erlang é funcional, mas com um plus que me interessa muito, concorrência! Além de outra coisa que eu sempre quis em Ruby ou Python, pattern matching, o que faz meus olhos geeks brilharem!

Lançado 1.0rc1, Wooohoooo! E veja a nova documentação, que sempre foi um ponto muito forte no Django.

O Google lançou o Chrome! Subprocessos, threads, webkit, V8, opensource! Em um teste de 2 minutos numa VM com Windows posso dizer que ele é lindo!

Por falar em subprocessos, Python 2.6 foi lançado tem suporte a eles, quer dizer, uma ótima alternativa as threads e o GIL!

Essa semana começou ótima!

Lendo esse post aqui onde ele fala que alguma coisa deu errado com o Linux eu só tenho a falar uma coisa, graças a Deus. Ele não tem essa fatia de mercado por causas que vão bem além do KDE ou do GNOME. A usabilidade de um Gnome é muito boa na verdade! De fato um grande problema são drivers. Drivers (ATI…) e especificações fechadas da Microsoft (SMB…) e outras são grandes problemas! Mas o Linux é seguro, é confiável e tem inúmeras vantagens que o Windows nem pensa em ter…

A briga também não é só para quem tem um rosto bonito não, fique atento no desenvolvimento do Kernel, do Wine, do Gnome. Não é só concurso de quem tem a melhor cara, e sim de quem tem a melhor interface e o melhor desempenho.

Os desenvolvedores de SO não se esquecem da web2.0 não, web2.0 é algo novo, onde o contexto realmente relevante é conteúdo, leva tempo os aplicativos de um SO se adaptarem a essa nova realidade, mas muitos já estão como Photoshop, Firefox ou F-spot.

Outro problema grande é que boa parte dessas aplicações usam flash ou muito javascript, para isso nossos browsers tem que ser bastante rápidos e as equipes do Firefox ou Webkit por exemplo já estão correndo atrás para prover a tecnologia que aplicativos com base na web precisam.

Web é realmente a plataforma que vai vingar para boa parte dos softwares mas os SOs vão sim tem um papel importante, não quero usar meu banco online e um vírus entrar no meu pc, pegar minha senhas e tirar dinheiro da minha conta.

Sou desenvolvedor, uso Linux, e não sou xiita não, OSX é massa Sou 1% feliz em não ter que me preocupar com segurança, estabilidade e ter na minha mão algo que realmente posso utilizar e tirar proveito da melhor maneira possível!

ps: FreeBSD não é Linux!

*Esse post foi escrito em um Laptop HP, usando Archlinux (sem dual boot), Firefox e Awesome, ah, Windows XP não instala com o SATA habilitado, não tem driver…

Bem, minhas experiências com o Solaris 10 não foram das melhores, Linux é user friendly
Mas hoje tive boas horas com ele, instalei o Dtrace e vi que realmente é uma ferramenta bastante legal, pensando até em instalar o Open Solaris na máquina, mesmo que seja no virtual-box.

Bem, um código vale mais que mil palavras:

$array = array(1, 2, 3, 4, 5);
array_map(function($text) { echo $text, PHP_EOL; }, $array);

Via http://gist.github.com/4646 e http://wiki.php.net/rfc/closures

Para quem detesta a interface do classificados do Diário do Nordeste (Fortaleza):

#!ruby
require 'rubygems'
require 'hpricot'
require 'open-uri'
doc = Hpricot(open("http://diariodonordeste.globo.com/classif/consultando.asp?Filtro=#{$*[0]}&Operador=OU&Filtro2="))
doc.search(".anuncio").each do | anuncio |
    puts '****'
    puts anuncio.inner_text.strip
    puts anuncio.inner_text.scan(/[0-9]{4}+\.[0-9]{4}+/)
end

Para usar:
ruby diario.rb notebook

Eu queria ver as estatísticas do memcached, então resolvi procurar na internet e achei isso: http://lists.danga.com/pipermail/memcached/2003-October/000354.html, mas ai resolvi mudar um pouco para pegar todos os dados e virou:

#!/usr/bin/perl
use IO::Socket;
my $socket = IO::Socket::INET->new( PeerAddr => $ARGV[0],
                                    PeerPort => $ARGV[1],
                                    Proto    => "tcp",
                                    Type     => SOCK_STREAM)
					or die($@);
print $socket "stats\n";
$out = <$socket>
while ($out ne "END\r\n") {
    if ($out =~ m/STAT (\w+) ([0-9.]+)/) {
        print "$1 $2\n";
    }
    $out = <$socket>
}
close($socket);

*Para usa: ./memcachecheck.pl IP PORTA

Mas ai um colega de trabalho (Rudy Matela) me falou que podia ser feito em shell script:

#!/bin/sh
echo -e 'stats\nquit' | netcat $1 $2 | grep STAT | sed -e "s/STAT //"  -e "s/ /\\t/"

* Para usa: ./memcachecheck.sh IP PORTA

Muito mais legal! Porém resolvi também fazer em Ruby:

#!/usr/bin/ruby
require 'socket'
out = TCPSocket.open($*[0],$*[1]) do |socket|
  socket.puts 'stats'
  socket.puts 'quit'
  socket.read
end
out.each { |line| print line.gsub(/STAT /,"") if line =~ /STAT (\w+) ([0-9.]+)/ }

* Para usa: ./memcachecheck.rb IP PORTA

Um colega estava com um problema, algo como isso aqui não funcionava como ele desejava:

def g
x = Proc.new { return 'ok' }
x.call
puts "Não irá mostrar isso"
end

Depois da chamada do pro x não se conseguia mais executar o resto da função. Ai tentando com lambda:

def g
x = lambda { return 'ok' }
x.call
puts "Irá mostrar isso"
end

Depois da chamada de x a função continuava a ser executada, procurando a diferença, bem é o seguinte, todo o centexto externo é passado para o Proc e assim se é chamado return ele não só executa return no escopo dele, ele executa um return no escopo externo! O mesmo não acontece com o lambda, que apesar de ver o contexto externo ele não “pega” para si esse contexto e usa como se fosse o dele.

Olhe esse exemplo:

def x
  y = 1
  f = Proc.new{ return y + 1 }
  f.call
  puts y
end

def z
  h = 1
  f = lambda { return h + 1 }
  f.call
  puts h
end

puts 'x:'
x()
puts 'z:'
z()

Vai imprimir:

x:
z:
1

Olhem esse outro:

def x
  y = 1
  puts Proc.new{ y = y + 1 }.call
  puts y
end

def z
  h = 1
  puts lambda { h =  h + 1; return h }.call
  puts h
end

puts 'call x'
x()
puts 'call z'
z()

No proc ele muda o valor e sem o return dentro ele não saí do contexto de x, já o lambda altera o valor e mesmo com return não sai do contexto de z.

call x
2
2
call z
2
2

Veja mais aqui e aqui.

Quando forem colocar o gitweb em um servidor para sevir repositórios sem working copy e com working copy, lembre-se de colocar o usuário do servidor no grupo que tenha acesso a pasta do repositório, aparentemente se ele não estiver no grupo os repositórios criados com a opção “–bare” não aparecem listados.