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.

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!

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…

$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

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

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

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.