Normalizing latin chars (á, é, ç, …) to ASCII chars (a, e, c, …) in our search index and queries was pretty easy. We changed the text field definition to the following schema:

1
2
3
4
5
6
7
8
9

<fieldType name="text" class="solr.TextField" omitNorms="false">
	<analyzer>
		<charFilter class="solr.HTMLStripCharFilterFactory"/> <!-- strip HTML -->
		<tokenizer class="solr.StandardTokenizerFactory"/>
		<filter class="solr.StandardFilterFactory"/>
		<filter class="solr.LowerCaseFilterFactory"/>
		<filter class="solr.ASCIIFoldingFilterFactory"/> <!-- convert accented chars to ASCII -->
	</analyzer>
</fieldType>

A more difficult problem was to sort accented string fields. By default, the class of the sunspot’s string field is solr.StrField. The string field is used for sorting, but was showing problems to sort accented inputs. For the inputs “árvore”, “bola”, “ano” it was showing the sorted result: “ano”, “bola”, “árvore” (the correct result would be “ano”, “árvore”, “bola”).

The problem with accented chars sorting is that non-ASCII chars are represented as HTML entites (for example, á instead of á) and special chars as “&” goes after alphanumeric chars in a sort.

To solve this, we changed the string field’s class to solr.TextField but making sure that its tokenizer would not create more than one token for each entry. The tokenizer we used was the KeywordTokenizer. The final schema for the string field was:

1
2
3
4
5
6
7

<fieldType name="string" class="solr.TextField" omitNorms="true">
	<analyzer>
		<tokenizer class="solr.KeywordTokenizerFactory"/>
		<filter class="solr.LowerCaseFilterFactory"/>
		<filter class="solr.ASCIIFoldingFilterFactory"/>
	</analyzer>
</fieldType>

A melhor maneira que encontrei para fazer isso foi o Yahoo Pipes, que, de maneira resumida, é um gerador de fluxo, com diversas possibilidades de filtros e ações.Para explicar melhor o que o Pipes faz, é mais fácil dar exemplos.

Assinava o feed do Lifehacker completo, mas, meu real interesse eram dicas sobre Macs. Para tal, filtrava com o poder do meu cérebro, tentando, rapidamente, achar a palavra “Mac” nas notícias. Obviamente perdia muito tempo e a taxa de erro era imensa. Fazer um programa em PHP, Ruby on Rails ou qualquer outra coisa similar, seria fácil, mas, não tanto quanto criar um fluxo no Yahoo Pipes.

Para isso, basta ter uma conta do Yahoo, acessar o Pipes e começar a criar. Ou, ainda, buscar por fluxos que outros criaram e que servem ao seu propósito.

Esse do Lifehacker é bem simples, mas dá pra fazer coisas inacreditáveis. Cheguei a criar um fluxo que dava parse num HTML para gerar um RSS. Não é a coisa mais fácil do mundo – qualquer um que já tentou encontrar lógica num HTML sabe do que estou falando –, mas, é bem mais fácil do que fazer seu próprio programa, arrumar um local na web para colocá-lo e só então poder usá-lo.

Como se vê a seguir, meu fluxo pega o feed do Lifehacker e busca em cada campo pelas palavras “mac”, “os x” ou “ios” e colocam isso no output.

Filtros e output do Yahoo Pipes do Lifehacker.

A ferramenta funciona com drag-and-drop. Na esquerda, existem diversas opções de entrada, filtros e lógicas que podem ser aplicadas. Basta selecionar e juntar de maneira sequencial as ações.

Outra sequencia que criei foi para filtrar as novas legendas do Legendas.tv para ver apenas as séries que eu acompanho. Não está 100% ainda, pois a busca é com “ous” e, portanto, tenho que remover coisas como “desperate” para que ele ache “house”, mas não “desperate housewifes”. Mas, com certeza filtrar manualmente algumas coisas incorretas é bem mais fácil do que o processo antigo.

Filtros e output do Yahoo Pipes do Legendas.tv

Neste exato momento, estou criando um Pipe para tentar transformar em RSS as suspensões de rodízio de SP da CET. Será um parto, mas, sei que é possível. Para ver meus Pipes, basta entrar no meu perfil. Se você tem algum Pipe interessante ou alguma dica e quer compartilhar, deixe nos comentários.

Aliás, inserção de código fonte foi o que me fez querer usar LaTeX a primeira vez. Não fosse isso, estaria fazendo o TCC no Word, sou fã de GUI, prefiro GUI, mas a facilidade de deixar as coisas bonitas no LaTeX pra um texto monstro como a monografia de conclusão de curso me convenceram.Antes de tudo, algumas coisas em relação aos arquivos e definições: lí, sei lá aonde, que a melhor coisa é usar UTF-8 para os arquivos, mas, se você fizer isso em TODOS os arquivos, perceberá que acentuação não funcionará com códigos fonte! Então seus arquivos vão ficar meio misturados: Texto e Bibliografia em UTF-8 e códigos em Latin1.

Para isso, você precisa prestar atenção na hora de salvar os arquivos no TextMate:

Codificações do TextMate na hora de salvar

Agora vamos às definições que você precisa colocar no sue LaTeX pra poder inserir códigos fonte “bonitinhos”. Esses são os pacotes que você precisará para isso:

1
2
3

\usepackage[<strong>utf8</strong>]{inputenc}
\usepackage{color} % permite cores nos gráficos e códigos
\usepackage{listings} % para importação de códigos fonte

Depois disso, você precisará criar o comando de inserção de código (perceba que aqui foi selecionado latin1):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

\renewcommand{\lstlistingname}{Código} % definição visual dos códigos fonte
\lstset{
 extendedchars=\true, % permite acentos
 <strong>inputencoding=latin1</strong>, % usa Latin1 nos códigos fonte
 commentstyle=\it, % deixa os comentários em itálico
 stringstyle=\bf, % não lembro o que faz, mas está funcionando
 belowcaptionskip=5pt, % não lembro o que faz, mas está funcionando
 numbers=left, % coloca a numeração na esquerda
 stepnumber=1, % passos da numeração
 firstnumber=1, % primeira linha
 numberstyle=\tiny, % tamanho da fonte da numeração
 breaklines=true, % permitir quebra de linha
 frame=tb, % borda em cima e em baixo
 basicstyle=\footnotesize, % estilo básico
 stringstyle=\ttfamily, % não lembro o que faz, mas está funcionando
 showstringspaces=false, % não mostrar os espaços
 mathescape, % não lembro o que faz, mas está funcionando
 tabsize=3 % tamanho da tabulação
}

Com isso, basta alguns comandos e você consegue inserir um código fonte no seu LaTeX e, para facilitar ainda mais a vida, um Bundle de drag and drop pro TextMate.

Essa inserção de código fonte reconhece algumas linguagens nativamente, mas, mesmo tipos não reconhecidos ficam bem com isso.

Seguindo os mesmos passos do artigo de inserção de PNGs, aperte CMD+OPTION+CNTRL+B, troque de “show all” para “drag commands”, vá até “LaTeX”.

Agora clique no botão de + e adicione um “New Drag Command”. chame como quiser… adicione as extensões de código fonte que prentende usar,  eu coloquei o seguinte: ada, ant, asm, as, c, cpp, htm, html, java, js, json, pl, php, py, rb, sh, sql, xml, vhdl.

Coloque no “Scope Selector”:

text.tex.latex

Agora insira o seguinte código:

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

#!/usr/bin/env ruby
require 'pathname'
require "#{ENV['TM_BUNDLE_SUPPORT']}/lib/LaTeXUtils.rb"
filename = ENV["TM_DROPPED_FILEPATH"]
relative_to = ENV["TM_DIRECTORY"]
startfile = ENV['TM_LATEX_MASTER'] || ENV['TM_FILEPATH']
master = Pathname.new(LaTeX.master(startfile))
unless master.absolute?
 master = master.expand_path(ENV['TM_PROJECT_DIRECTORY'])
end
path = Pathname.new(filename).relative_path_from(master.dirname)
if ENV["TM_MODIFIER_FLAGS"].match(/SHIFT/)
 print "\\\\input{" + path + "}"
else
 ext = File.extname(path)
 file_type = case ext
 when ".ada" then "Ada"
 when ".ant" then "Ant"
 when ".asm" then "Assembler"
 when ".as" then "Assembler"
 when ".c" then "C"
 when ".cpp" then "C++"
 when ".htm" then "HTML"
 when ".html" then "HTML"
 when ".java" then "Java"
 when ".js" then "Java"
 when ".json" then "Java"
 when ".pl" then "Perl"
 when ".php" then "PHP"
 when ".py" then "Python"
 when ".rb" then "Ruby"
 when ".sh" then "sh"
 when ".sql" then "SQL"
 when ".xml" then "XML"
 when ".vhdl" then "VHDL"
 else "linguagem"
 end
 puts ["\\\\lstinputlisting[language=\${1:#{file_type}}, tabsize = \${2:4}, caption={\${3:caption}}, label = {code:\${4:#{path.to_s.gsub(/(\.[^.]*$)|(\.\.\/)/,"").gsub(/\//,"_")}}}]{#{path}}"].join("\n")
end

Se você entende um pouquinho de programação, percebeu que é só acrescentar mais uma linha no case para inserir outras linguagens.

O meu ficou assim:

Criação do Bundle para inserção de código fonte com drag and drop

Dessa forma, sempre que arrastar um código com uma dessas extensões, automaticamente a linha de inserção de código fonte já vai aparecer parcialmente preenchida, bastando apertar TAB para ir para o próximo campo.

Mas, o TCC do Anauê Costa, que usei como base, tinha um “\newcommand” que simplificava o processo de inserção de imagens (adicione isso nas definições do seu LaTeX):

1
2
3
4
5
6
7
8

\newcommand{\inputpng}[4]{%
 \begin{figure}[!htb]
 \centering
 \includegraphics[width=#4\textwidth]{#1.png}
 \caption{\it #3.}
 \label{fig:#2}
 \end{figure}
 }

então, em vez de:

1
2
3
4

\includegraphics[width=1.0\textwidth]{figuras/p-30-1-multiplataforma-marketshare_gartner.png}
 \caption{caption}
 \label{fig:figuras_p-30-1-multiplataforma-marketshare_gartner}
 \end{figure}

você fica com:

1

\inputpng{figuras/p-30-1-multiplataforma-marketshare_gartner}{figuras_p-30-1-multiplataforma-marketshare_gartner}{caption}{1.0}

Fiz então uma alteração no comando de inserção de imagem pra ele gerar o novo tipo quando arrastar uma imagem.

Para inseri-lo, no TM, aperte CMD+OPTION+CNTRL+B. Isso abrirá o editor de bundles.

Troque de “show all” para “drag commands“, vá até “LaTeX” e selecione o “Include Image“.

Tire a extensão “png” de lá, já que o comando novo só serve para PNG!

Agora clique no botão de + e adicione um “New Drag Command”

chame como quiser… adicione a extensão PNG e cole o código abaixo nele:

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

#!/usr/bin/env ruby
 require 'pathname'
 require "#{ENV['TM_BUNDLE_SUPPORT']}/lib/LaTeXUtils.rb"
 filename = ENV["TM_DROPPED_FILEPATH"]
 relative_to = ENV["TM_DIRECTORY"]
 startfile = ENV['TM_LATEX_MASTER'] || ENV['TM_FILEPATH']
 master = Pathname.new(LaTeX.master(startfile))
 unless master.absolute?
 master = master.expand_path(ENV['TM_PROJECT_DIRECTORY'])
 end
 path = Pathname.new(filename).relative_path_from(master.dirname)
 case ENV['TM_MODIFIER_FLAGS']
 when /OPTION/
 puts ["\\\\begin{center}",
 " \\\\includegraphics[height=\${1:3in}]{#{path}}",
 "\\\\end{center}"].join("\n")
 when /SHIFT/
 
puts ["\\\\begin{figure}[\${1:htbp}]",
 "    \\\\centering",
 "        \\\\includegraphics[height=\${2:3in}]{#{path}}",
 "    \\\\caption{\${4:caption}}",
 "    \\\\label{fig:\${5:#{path.to_s.gsub(/(\.[^.]*$)|(\.\.\/)/,"").gsub(/\//,"_")}}}",
 "\\\\end{figure}"].join("\n")
 else
 puts "\\\\inputpng{#{path.to_s.gsub(".png", "")}}{\${1:#{path.to_s.gsub(/(\.[^.]*$)|(\.\.\/)/,"").gsub(/\//,"_")}}}{\${2:caption}}{\${3:1.0}\}"
 end

Adicione também no “Scope Selector” o seguinte:

1

text.tex.latex

Com isso, sempre que você arrastar um PNG pro .tex, ele já vai gerar o código automagicamente!

Segue a imagem de como ficou aqui.

Novo Bundle do TextMate para inserção de imagem em Latex.

Para inserir “PNGs” da forma “original”, basta pressionar SHIFT quando arrastar a imagem.

Observação: Esse é um post transcrito de um e-mail, na pressa, no meio da correria de escrever o TCC da Poli, então, não está bem formatado, cheio de imagens ilustrativas ou coisas do tipo… sorry

Este artigo analisa técnicas e softwares que o Facebook usa para funcionar nesse nível.

Facebook: desafio de escalabilidade

Antes de entrar em detalhes, aqui estão alguns factóides para dar uma idéia do desafio de escalabilidade com o qual o Facebook tem que lidar:

• O Facebook serve mais de 550 bilhões de visualizações de páginas por mês;

• Há mais fotos no Facebook do que em todos os outros sites de fotos juntos (incluindo sites como o Flickr);

• Mais de 3 bilhões de fotos são visualizadas por dia;

• Mais de 25 bilhões de tipos de conteúdo (atualizações de status, comentários, etc) são compartilhados todo mês;

• O Facebook tem mais de 60 mil servidores.

Softwares para escalar

A infraestrutura de software que o Facebook usa pode ser vista como a de um site LAMP, mas com melhorias e extensões de vários serviços. Por exemplo:

• O Facebook usa PHP, mas tem um compilador que permite que o sistema execute código nativo nos servidores web, aumentando significativamente seu desempenho;

• O Facebook usa Linux, mas é um Linux otimizado para garantir alta vazão de rede;

• O Facebook usa MySQL, mas principalmente para persistência de chaves-valores (Hashes), movendo lógicas de consultas e JOINS para a camada de aplicação dos servidores web em que otimizações são mais fáceis de implementar, usando por exemplo caches em memória;

• Por fim, há sistemas customizados, como o Haystack, um objeto de armazenamento altamente escalável usado para servir a imensa quantidade de fotos do Facebook, e o Scribe, um sistema de logging (registro de ações) que consegue operar na escala do Facebook (nada trivial).

Vamos ao que interessa. Abaixo são apresentados os softwares (alguns) que o Facebook usa para fornecer a todos nós a maior rede social do mundo.

Memcached

O Memcached é no momento um dos softwares mais famosos na Internet. É um sistema de cache em memória distribuído que o Facebook (e vários outros sites) usam como uma camada de cache entre aplicação web e banco de dados (já que acesso a disco rígido é relativamente lento). Ao longo dos anos, o Facebook realizou diversas otimizações no Memcached e nos softwares que rodam em conjunto com ele.

O Facebook roda milhares de servidores Memcached com dezenas de tearabytes de dados em cache a todo momento. É provavelmente a maior instalação de Memcached do mundo.

HipHop for PHP

PHP é uma linguagem interpretada e por isso seu código quando executado é relativamente lento quando comparado com código que executa nativamente. O HipHop converte PHP em código C++ que pode ser então compilado e apresentar um desempenho melhor. Isso permite que o Facebook aproveite muito melhor seus servidores web já que dependem demais de PHP para servir conteúdo.

Uma pequena equipe de engenheiros no Facebook (inicialmente, apenas três) passou 18 meses desenvolvendo o HipHop, que agora é usado em produção.

Haystack

Haystack é o sistema de armazenamento e recuperação de fotos de alto desempenho do Facebook (a rigor, o Haystack é um armazenador de objetos, então ele não armazena apenas fotos). Existem mais de 20 bilhões de fotos no Facebook e cada uma é armazenada em quatro diferentes resoluções, resultando em mais 80 bilhões de fotos.

O desafio do Haystack não é apenas armazenar bilhões de fotos, mas também executar tarefas com elas em que o desempenho é crítico, como por exemplo remoção, atualização ou acesso.

BigPipe

O BigPipe é um sistema dinâmico para servir páginas web que o Facebook desenvolveu. Ele é capaz de dividir uma página em seções (chamadas “pagelets“) e servi-las em paralelo com desempenho ideal.

Por exemplo, a janela de chat é carregada separadamente, o feed de notícias é carregado separadamente, e assim por diante. Esses “pagelets” podem ser carregados em paralelo, que é de onde vem o ganho de desempenho, e os usuários recebem um site que funciona mesmo se uma parte dele for desativada ou estiver com defeitos.

Cassandra

Cassandra é um sistema de armazenamento distribuído baseado no projeto do BigTable. Ele é um dos filhos de destaque do movimento NoSQL e se tornou open source (virou um projeto Apache). O Facebook o usa na pesquisa Inbox.

Além do Facebook, uma série de outros sites também o usam, como o Twitter e o Digg. É um sistema capaz de armazenar uma quantidade imensa de dados sem comprometer o tempo de busca e acesso a eles.

Scribe

Scribe é um sistema de logging flexível e escalável que o Facebook usa para uma infinidade de propósitos internos. Ele foi criado para ser capaz de registrar todas as ações ocorridas no Facebook, e automaticamente lida com novas categorias de ações registradas conforme aparecem (o Facebook tem centenas).

Hadoop e Hive

O Hadoop é uma implementação open source de MapReduce que permite a execução de cálculos em uma quantidade massiva de dados. O Facebook o usa para análise de dados de sua rede. O Hive é uma interface de acesso ao Hadoop através de consultas SQL, facilitando seu uso, e teve origem dentro do Facebook.

Tanto o Hadoop quanto o Hive são open source (projetos Apache) e são usados por uma série de grandes sites, como o Yahoo e o Twitter.

Thrift

O Facebook usa diferentes linguagens para os seus diferentes serviços. PHP é usada para front-end, Erlang é usada para Chat, Java e C++ são usados em diversas áreas. Thrift é um framework cross-language desenvolvido internamente que junta todas as diferentes linguagens, permitindo que elas conversem entre si. Isso facilita enormemente o desenvolvimento cross-language no Facebook.

O Facebook tornou o Thrift open source e adicionou suporte a mais linguagens de programação.

Varnish

O Varnish é um acelerador HTTP, que pode agir como um balanceador de carga e também realiza cache de conteúdo para servi-lo rapidamente.

O Facebook usa o Varnish para servir fotos, lidando com bilhões de requisições todos os dias. Como quase tudo que o Facebook usa, o Varnish também é open source.

Outras coisas que ajudam o Facebook a funcionar bem

Foram mencionados os softwares que constituem o Facebook e o ajudam a escalar. Mas operar um sistema tão grande é uma tarefa complexa, por isso serão listadas outras coisas que ajudam o Facebook a funcionar sem problemas:

Lançamento gradual de novas funcionalidades e execuções no escuro

O Facebook tem um sistema chamado de “Gatekeeper” (porteiro) que permite que eles rodem diferentes versões do sistema para diferentes conjuntos de usuários. Ele permite que o Facebook lance novas funcionalidades gradualmente e que testes A/B sejam realizados com usuários.

O “Gatekeeper” também é responsável por realizar o que é chamado de “dark launches” (lançamentos no escuro), que é a ativação de elementos de uma nova funcionalidade antes de ela ir pro ar. É uma maneira de realizar testes de carga do sistema antes de uma funcionalidade ser oficialmente lançada. Normalmente os “dark launches” são realizados duas semanas antes do lançamento oficial da funcionalidade.

Monitoramento do sistema em produção

O Facebook cuidadosamente monitora seu sistema e o desempenho de cada função PHP executada em ambiente de produção. Com isso é possível projetar um perfil do sistema que está no ar com a ajuda de uma ferramenta chamada XHProf e identificar gargá-los ou áreas que estão operando incorretamente.

Desativação gradual de recursos para aumento de desempenho

Se o Facebook tiver algum problema de desempenho, existe um grande número de recursos não-críticos que podem ser desativados para aumentar o desempenho de funcionalidades vitais da rede social. Desta forma, em uma situação de emergência, o núcleo da rede social poderá continuar funcionando normalmente.

Coisas que não foram mencionadas

O hardware usado pelo Facebook não entrou em discussão neste artigo, mas é um aspecto importante de analisar quando se pensa em escalabilidade. Por exemplo, o Facebook usa a rede CDN para servir conteúdo estático e possui enormes data centers que hospedam milhares de servidores.

E além do que foi mencionado, existem diversos outros softwares envolvidos na operação do Facebook. Neste artigo foram destacadas as escolhas mais interessantes que o Facebook fez.

Facebook e projetos open source

Antes de encerrar o artigo, é importante mencionar o quanto o Facebook, assim como outras grandes empresas de Internet, apoia projetos open source. O Facebook não apenas usa e contribui com software open source como Linux, Memcached, MySQL e Hadoop, como também desenvolve internamente diversas ferramentas que são disponibilizadas como projetos open source.

Uma lista com todos os projetos open source em que o Facebook atua pode ser encontrada na página Open Source – Desenvolvedores do Facebook.

Mais desafios de escalabilidade por vir

O Facebook cresce a passos incríveis. Sua base de usuários aumenta quase que exponencialmente e já superou 500 milhões de usuários. Ele tem mantido uma taxa de cerca de 100 milhões de novos usuários a cada 6 meses.

O rápido crescimento significa que o Facebook vai ter problemas e diversos desafios de desempenho para apresentar cada vez mais páginas, buscas, imagens, mensagens e todos os outros recursos com os quais os usuários interagem. Para um site como o Facebook, este sempre será um fato com o qual ele terá que viver, e seus engenheiros estarão sempre atentos e criando novas maneiras de fazer o sistema escalar.

Vamos acompanhar o que os engenheiros do Facebook estão desenvolvendo! Com certeza surgirão coisas interessantes, afinal de contas, eles estão escalando uma montanha que muitos de nós podemos apenas sonhar; um site com mais pessoas do que a maioria dos países. Quando isso acontece, é preciso ser criativo.

Este artigo é uma adaptação/atualização para o português do artigo em inglês Exploring the software behind Facebook, the world’s largest site.

O exemplo que vai guiar este artigo é a criação de um aplicativo que extrai o preço de um produto qualquer do site da Fast Shop. Ele será usado para encontrarmos o preço do MacBook White.

1. Instalando Ruby + RubyGems

Se você usa Windows, baixe e instale a última versão estável do interpretador Ruby clicando aqui.

Se você usa Mac OS X, Solaris ou uma distro linux popular, seu sistema já vem com Ruby instalado.

RubyGems é um gerenciador de pacotes (programas e bibliotecas) para Ruby. Para instalá-lo, baixe a última versão do aplicativo clicando aqui e execute o comando abaixo no diretório com o arquivo descompactado:

ruby setup.rb
gem update --system

2. Instalando Nokogiri

Mac OS X

sudo port install libxml2 libxslt
sudo gem install nokogiri

Ubuntu/Debian

# pacotes de desenvolvimento ruby
sudo apt-get install ruby1.8-dev ruby1.8 ri1.8 rdoc1.8 irb1.8
sudo apt-get install libreadline-ruby1.8 libruby1.8 libopenssl-ruby
 
# requisitos do nokogiri
sudo apt-get install libxslt-dev libxml2-dev
sudo gem install nokogiri
 
# requisitos do nokogiri para Hardy (8.04) ou uma versão mais atual
sudo apt-get install libxslt1-dev libxml2-dev

Windows

gem install nokogiri

3. Baixando a página do produto

O trecho de código que baixa a página do MacBook se encontra abaixo:

1
2
3
4
5
6
7
8

# url do produto
url = 'http://www.fastshop.com.br/MACBOOK-WHITE-COM-INTEL-CORE-2-DUO--2GB--HD-250GB--TELA-133--PLACA-GRAFICA-NVIDIA-GEFORCE-320M-COM-256MB--SISTEMA-OPERACIONAL-MAC-OS-X-LEOPARD---APPLE---MC516BZA,product,AEMC516BZA,3.aspx'
 
# html da página
html = Net::HTTP.get URI.parse(url)
 
# html analisado pelo nokogiri
doc = Nokogiri::HTML(html)

4. Extraindo o preço do produto

Para extrair o preço do produto a partir do HTML baixado, vamos utilizar o plugin Firebug para analisar a estrutura do HTML. Ele permitirá que encontremos o XPath (XML Path Language) do elemento que contém o preço do produto.

Na captura de tela abaixo, podemos ver como isso é feito:

Verificamos que a seguinte estrutura de nós de HTML guarda o preço do produto:

<div id="boxInfosPagamento">
   <p class="preco">
        <span>PRECO DO PRODUTO</span>
   </p>
</div>

Podemos traduzir essa estrutura para o seguinte XPath:

"//div[@id='boxInfosPagamento']/p[@class='preco']/span"

5. Aplicativo final

O aplicativo final que imprime o preço do produto pode ser visto abaixo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# importando bibliotecas necessárias:
require "rubygems"
require "nokogiri"
require "net/http"
 
# url do produto
url = 'http://www.fastshop.com.br/MACBOOK-WHITE-COM-INTEL-CORE-2-DUO--2GB--HD-250GB--TELA-133--PLACA-GRAFICA-NVIDIA-GEFORCE-320M-COM-256MB--SISTEMA-OPERACIONAL-MAC-OS-X-LEOPARD---APPLE---MC516BZA,product,AEMC516BZA,3.aspx'
 
# html da página
html = Net::HTTP.get URI.parse(url)
 
# html analisado pelo nokogiri
doc = Nokogiri::HTML(html)
doc.encoding = 'utf-8'
 
# preço do produto
puts doc.xpath("//div[@id='boxInfosPagamento']/p[@class='preco']/span")[0].inner_html

A captura de tela abaixo mostra a execução do aplicativo:

6. Conclusões

Nokogiri é uma biblioteca muito robusta que suporta seleção de elementos com XPath ou seletor CSS3 de forma simples e eficiente. Sempre que precisar analisar XML ou HTML, considere usá-la em seu projeto.

Em artigos futuros vou falar mais sobre extração e análise de informações da Internet. Se tiver alguma dúvida ou sugestão de tema, deixe seu comentário!

Lançado no começo do mês, o aplicativo facilita muito subir arquivos para compartilhar com quem você quiser, seja usando o Twitter, seja enviando um e-mail com o link.

CloudApp instalado na barra de menus

Depois de se cadastrar no site – grátis, com a única limitação de arquivos não serem maiores que 50 MB – e instalar o programa, que fica alojado na barra de menus, basta arrastar “qualquer coisa” para cima dele ou usar a tecla de atalho (você pode definir a que quiser – eu estou usando CMD+SHIFT+2, já que isso se parece com os atalhos para tirar fotos da tela – para “qualquer coisa” ser enviada para os servidores deles.

Assim que o arquivo termina de subir, o endereço do tipo “http://cl.ly/xxx” é colocado no seu clipboard, bastando um CMD+V para colar o endereço. Além disso, ele te avisa, com som ou usando o Growl que o upload terminou.

Growl avisando que o arquivo foi enviado

O programa ainda conta com Raindrops, plugins que permitem que o atalho de envio de arquivo funcione com diversos programas. Basta baixar, clicar duas vezes e sair usando!

Raindrops instalados

Para completar o pacote, como todo bom encurtador de URL, o CloudApp te mostra quantas vezes cada link foi clicado, tanto pelo aplicativo na barra de menus, quanto pelo site.

Estatísticas de downloads no site

Quando se clica num link de arquivo que não pode ser aberto nativamente pelo browser (PDFs, DOCs, ZIPs e coisas do tipo), você é levado para uma tela com opção de download, já, quando é uma imagem ou uma URL, o programa abre o link diretamente no lugar.

Download de arquivo "não nativo" do browser

Resumindo… se você tem um Mac, baixe o CloudApp agora, que é, até o momento, totalmente grátis.

Fonte: MacMagazine e Lifehacker

Logo do OpenCV

Neste post irei dividir com você as experiências que já tive com a instalação da bibliteca OpenCV no Ubuntu. Vou relatar o processo de instalação do OpenCV 1.1 nas versões 8.10, 9.04 e 9.10 do Ubuntu.

Apesar do OpenCV ser tipicamente utilizado com C ou C++, também é possível utilizá-lo com Python (ou Octave) graças aos wrappers criados por terceiros ou ao que já acompanha a versão 1.1 da biblioteca.  Neste texto, focarei a instalação para o uso de Python com o wrapper Ctypes OpenCV. Por que o Ctypes OpenCV? Pois o que acompanha a biblioteca me “deixou na mão” durante o desenvolvimento do último projeto.

.

Passo zero:

(vale para todos as três versões do Ubuntu)

• O OpenCV, funciona com Python, apenas para as versões 2.5.x ou 2.6.x da linguagem. A versão 3.x ainda não tem suporte oficial. Logo, verifique se você possui ele instalado em seu computador, caso contrário, instale o Python 2.6.4.
• Mais umas coisinhas a serem instaladas. Digite no terminal (Aplicativos -> Acessórios -> Terminal) o comando abaixo. Sim, são várias coisas. Algumas são realmente requisitos para a instalação, outras servem apenas para diminuirmos chances de problemas depois. Instale, não dói nada

 sudo apt-get install build-essential libgtk2.0-dev libavcodec-dev
libavformat-dev libavfilter-dev libswscale-dev libtiff-dev libjasper libgstreamer0.10-dev
libxine-dev libunicap-dev libdc1394-22-dev swig ffmpeg mplayer vlc 

• Baixe o OpenCV 1.1, o Ctypes-OpenCV e os exemplos de códigos do Ctypes OpenCV, você vai querer testar e consultar depois.

.

Ubuntu 8.10:

Nesta versão do Ubuntu, a instalação é bem simples e funciona bem. Basta seguir os passos abaixo:

• Após o passo zero, no início desse post, descomprima o OpenCV e, pelo terminal,  entre na pasta criada. Se ela estiver em seu desktop, será algo próximo a:

 cd Desktop/opencv-1.1.0 

• Agora, digite:

 ./configure --disable-sse2 --with-python --with-swig --with-ffmpeg 

Obs.: Para processadores antigos, como o AMD de uns quase dez anos atrás que usei no laboratório, era necessários desativar instruções do tipo SSE2, caso contrário, ao rodar algum programa que usasse o OpenCV você obteria a mensagem: Illegal instruction. Eu não expliquei isso antes de você escrever o comando pois obtive problemas com os wrappers de python caso não desativasse esse tipo de instrução no Ubuntu 9.04 e 9.10, imagino que na versão 8.10 isso também ocorra apesar de não ter testado. Então, se você irá usar o OpenCV com C ou C++, não existe necessidade do –disable-sse2, caso contrário, é melhor desativar esse tipo de instrução.

• Agora preste atenção ao pequeno relatório que apareceu em seu terminal. Verifique, principalmente, se o python e o ffmpeg estão com “yes“. Seu relatório deve se parecer bastante como o da figura abaixo:

Figura 1 - Relatório do configure com as opções corretamente marcadas.

Caso o Python ou o ffmpeg não tenham aparecido com o “yes“, tente as soluções mostradas nas outras versões do Ubuntu que estão abaixo.

• Agora, digite:

 make 

• Depois que terminar, digite:

 sudo make install 

Será que funcionou? Vamos testar.

O OpenCV acompanha alguns programas exemplo, tanto em C quanto em Python, para você testar a instalação e aprender a usar a biblioteca.  Siga os passos abaixo.

• Se sua pasta do OpenCV estiver no desktop, digite:

 cd Desktop/opencv-1.1.0/samples/c 

• Agora compile os exemplos com:

 . build_all.sh 

• Agora rode um dos programas:

 ./delaunay 

Se surgiu uma nova janela e “coisas coloridas” estão aparecendo nela, a biblioteca foi instalada com sucesso.

Instalando o Ctypes OpenCV

Será bem simples. Descomprima o arquivo que você ja baixou no passo zero para o desktop e, pelo terminal, entre na pasta src. Após isso, digite:

 sudo python setup.py install 

Depois de instalado, veja os exemplos que você também baixou do Ctypes OpenCV no passo zero. Dê duplo clique em algum deles, por exemplo o delaunay.py. Ou então rode via terminal com o comando

 python delaunay.py 

.

Ubuntu 9.04:

Nessa versão do Ubuntu as coisas já não são mais tão simples. Apesar do processo de instalação ser o mesmo da versão 8.10, surgem alguns problemas no meio do caminho.

Primeiro problema: O Python não é reconhecido ao rodar o configure.

Se você rodar o configure, verá que no relatório que ele exibe aparece “no” para o Python. Se você verficar melhor a saída completa verá:

Figura 2 - Problema com o Python

Resolução: Provavelmente deve existir uma solução melhor, mas esta funcionou para mim. Baixei o source do Python 2.6.4, compilei e reinstalei via terminal, da seguinte forma:

./configure
make
sudo make install

Obs.: Se seu computador não possuir suporta a instruções SSE2, utilize para o primeiro comando: ./configure –diable-sse2

.

Segundo problema: O ffmpeg não é reconhecido ao rodar o configure. Resultado, não é possível manipular vídeos com a biblioteca.

Se você rodar o configure, verá que é exibido “no“ para o ffmpeg no relatório. Se você verficar melhor a saída completa verá:

Figura 3 - Problema com o ffmpeg

Resolução: Basta seguir os passos abaixo em seu terminal:

sudo mkdir /usr/include/ffmpeg
cd /usr/include/ffmpeg
sudo ln -s ../libavcodec/avcodec.h avcodec.h
sudo ln -s ../libavformat/avformat.h avformat.h
sudo ln -s ../libavformat/avio.h avio.h
sudo ln -s ../libavutil/avutil.h avutil.h
sudo ln -s ../libswscale/swscale.h swscale.h

Com os problemas resolvidos, e o passo zero realizado, siga o procedimento básico da instalação.

 ./configure --disable-sse2 --with-python --with-swig --with-ffmpeg --enable-swscale --enable-shared 

Antes dos próximos comandos, não esqueça de verificar no relatório do configure se o python e o ffmpeg estão com “yes“. Seu relatório deve se parecer bastante como o da Figura 1 desse post.

make
sudo make install

Ao terminar, teste e instale o Ctypes OpenCV para programar com Python. Para isso, siga as instruções dos tópicos “Será que funcionou? Vamos testar.” e “Instalando o Ctypes Opencv” que estão na instalação para o Ubuntu 8.10, acima neste mesmo post.

.

Ubuntu 9.10:

Nessa versão, existe mais um problema além dos já existentes para o Ubuntu 9.04.

Problema: Erro durante a compilação do código.

Resolução: Entre na pasta que você descomprimiu o OpenCV1.1, vá em cxcore, include e abra o arquivo cxmisc.h. Na linha 133, troque o

#elif

por:

#else

Para completar a instalação, basta seguir o texto acima sobre a instalação no Ubuntu 9.04.

.

.

Hoje à noite, em um momento iluminado (depois de ler um e-mail do Juca entitulado “algumas coisas demandam coragem”, sugerindo o que se segue), pensei: bom, se eu já uso as versões de desenvolvimento do Firefox e do Thunderbird cotidianamente, por que não o OpenOffice? Afinal, qual a graça de usar um OpenOffice 3.1 estável?!

Há cerca de dois anos eu tentei completar esse rito de passagem: na época ainda usavam CVS. Um grande problema de CVS em tutoriais é que sempre colocam umas linhas de comando do tipo:

cvs -d :pserver:anoncvs@anoncvs.services.openoffice.org:/cvs checkout "modulename"

e nunca nos dizem o que colocar em “modulename”, o que acaba por custar ao benevolente hacker mais duas horas varrendo o repositório em busca do módulo correto. Além disso, era necessário baixar e compilar separadamente todo o build system do open office.

A boa notícia é que a cada major version o OpenOffice.org tem refeito o seu build system, para melhor. Além disso, descobri que nesses dois anos eles passaram o repositório de código pelo svn e finalmente adotaram o mercurial em outubro de 2009.

Fazer um checkout de todo o repositório mercurial seria muito demorado, e por isso eles disponibilizam um bundle diário do repositório, isto é, um arquivo com todo o repositório empacotado.

Hora de se sujar: baixe o bundle , “unbundle” e “update”:

sudo apt-get install mercurial (caso não tenha o mercurial instalado)
mkdir devel && cd devel (ou como vc quiser chamar o seu parque de diversões hacker, caso ainda não o tenha)
wget http://hg.services.openoffice.org/bundle/DEV300.hg
mkdir openoffice
cd openoffice
hg init
hg unbundle ../DEV300.hg
hg pull http://hg.services.openoffice.org/DEV300
hg update

Além do tempo de baixar o bundle, que tem quase 1GB, o resto do processo demora cerca de 30 minutos.

De agora em diante, você é livre para compilar como quiser, com os itens opcionais que quiser (ou não). Vou apenas reproduzir o que eu fiz para executar um full build padrão, já que os tutoriais oficiais nunca são suficientes. Tudo isso foi executado em um Ubuntu GNU/Linux 9.04 (jaunty) 64bits, e pode mudar ligeiramente de distribuição para distribuição. Caso você use uma distribuição que não seja derivada do Debian (isto é, sem apt), use o gerenciador de pacotes padrão da sua distribuição. Os pacotes devem ter nomes iguais ou parecidos.

Dependências

No tutorial disponível no wiki eles sugerem algumas dependências:

• glibc:
  for OOo<=3.1: 2.2.x or higher for OOo>3.1: 2.3.2 or higher
• C/C++ Compiler:
  gcc >= 3.3
  gcc 4.2.3 is the current reference compiler
• The X11 development libraries and header files
• PAM including the development headers
• bash
• gtk2 and libtiff including the development headers

Se você não estiver usando um Debian Sarge da vida, ignore e prossiga. Ah, caso você não tenha o gcc instalado, 1. você não devia estar aqui (bazzinga!) 2. já que está aqui, rode um sudo apt-get install build-essential e seus problemas acabaram.

Isso é uma mão na roda para instalar a maioria das (infinitas) dependências:

sudo apt-get build-dep openoffice.org

Como de praxe, há coisas novas em relação à versão estável que obviamente o build-dep não pegou:

sudo apt-get install mingw32 libgraphite3 libgraphite-dev

De volta ao seu diretório openoffice:

./configure --with-use-shell=bash --with-system-libs --without-system-jars --without-system-icu --without-system-agg --without-system-lpsolve --without-system-mspack --disable-mozilla --with-mingwin=/usr/bin/i586-mingw32msvc-g++

Isso diz aos scripts de compilação para utilizarem o maior número possível de libs do sistema e evitar incompatibilidades. O palavrão /usr/bin/i586-mingw32msvc-g++ é para o cross-compilador mingw32, necessário para cross-compilar algo que não sei o que é. Ao final, veja se não ocorreram muitos warnings e se aparece a seguinte mensagem:

Configure completed
You may now run ./bootstrap in [pasta onde estão os sources]

Agora, com as variáveis de sistema configuradas, precisamos gerar os scripts de compilação (Makefiles):

./bootstrap
source LinuxX86-64Env.Set.sh
(ou source LinuxX86Env.Set.sh se seu processador for 32 bits)

Agora, aos finalmentes

Tendo configurado as variáveis de ambiente e gerado os build scripts, vamos à compilação:
time make

# vá tomar um chá que vai demorar (eu fui!). O time antes do make vai marcar o tempo gasto na compilação.

Depois do chá

Se tudo correr bem, depois do seu chá e mais algumas horas você chegará em algo assim:

***********************************************************
Successful packaging process!
***********************************************************
... creating log file log_DEV300_en-US.log
Fri Feb 5 12:30:15 2010 (00:07 min.)
real 357m1.283s
user 274m55.902s
sys 42m31.595s
rodrigo@snowball2:~/devel/openoffice$

Sim, foram 6 horas mesmo. Isso num Intel Core2 Duo T7250 2.00GHz com 4M de cache, mas utilizando apenas um núcleo. Coloque aí nos comentários os seus resultados para compararmos.

Caso você tenha um processador com dois ou mais núcleos, é possível fazer um build paralelo, que teoricamente iria mais rápido. Eu estava fazendo outras coisas no computador, então me contentei com um único core compilando o bichinho. No link ao final da página há instruções sobre como fazer isso, entre outros hacks.

Como executamos um full build, o processo gerou pacotes prontos para instalação. Os pacotes para GNU/Linux 64bit ficam em ~/devel/openoffice/instsetoo_native/unxlngx6.pro/OpenOffice/deb/install/ (para 32bits é unxlngi6.pro ou algo que o valha). Na pasta en-US_download há um tar.gz que pode ser distribuído. A pasta en-US possui o mesmo conteúdo, porém não compactado.

Instalação

Como executamos um build padrão, o configure gerou os pacotes nativos da distribuição: .deb. Caso você queira instalar o OO que compilou (óbvio que quer!) será necessário remover o OpenOffice que vem com a distribuição (se souber como gerar o build desempacotado e evitar isso, por favor faça um comentário).

sudo apt-get remove openoffice.org-common
(Caso você não remova o open office atual, pode haver conflito de pacotes. Remova!)

cd ~/devel/openoffice/instsetoo_native/unxlngx6.pro/OpenOffice/deb/install/en-US/DEBS
sudo dpkg -i *.deb (pacotes do OO.org)
cd destop-integration
sudo dpkg -i *.deb (ícones no menu do KDE/GNOME)

Lembre-se de autalizar o código (hg pull && hg update) e recompilar (make) de tempos em tempos. A linha de desenvolvimento está em constante… desenvolvimento (!), e se sua intenção vai além de fazer uma graça é importante estar com o código em dia. Vale lembrar que, a princípio, os rebuilds devem demorar muito menos, pois apenas os arquivos modificados (e os dependentes deles) são recompilados. Veja o link abaixo para maiores informações.

Agora, se suas intenções são realmente corajosas e vão além de testar e reportar bugs, entre na lista de e-mails dev@openoffice.org, dê uma olhada no bugtracker e na página de TODO’s. O wiki também é um ótimo ponto de partida.

happy hacking!

Referência:
http://wiki.services.openoffice.org/wiki/Documentation/Building_Guide/Building_on_Linux

© 2010 Rodrigo Rodrigues da Silva. Este texto pode ser compartilhado sob os termos da licença Creative Commons By-Sa

O grande salto quântico disso, era entender a tabela de interrupções do x86. Onde fica, para onde aponta e o que faz. Salto dado graças à imensa ajuda do Mestre Jorge Sabaliauskas! Se você não conhece o Jorjão, sinto muito!

Tabela de interrupção

Todo processador moderno possui uma tabela de interrupção (chamada de IDT – Interrupt Description Table – a partir daqui), que tem a função principal de executar uma determinada rotina (definida pelo SO) quando ocorre uma interrupção de hardware.

No x86, a tabela de interrupções é descrita conforme a tabela abaixo:

Tabela de exceções e interrupções retirada do manual "IA32-System-Programming-3A.pdf", Vol 3 5-3, para ser mais exato

Para entender um pouco melhor o que isso faz, usaremos o exemplo clássico da divisão por zero (não, não pode dividir por zero).

Sempre que algum programador tosco (como eu) solicitar uma divisão por zero (não pode mesmo!), o processador dá um berro e passa aponta o PC (Program Counter – o cara que aponta para o próximo trecho da memória a ser executado) para o endereço armazenado na posição zero da IDT.

A partir daí, o SO passa a tratar isso, inserindo o código de como quer tratar esse erro na posição apontada pela IDT.

Use Bochs, die alone

Antes de tudo, para conseguir encontrar o código apontado pela tabela de interrupção, você precisa usar o Bochs e com a versão de debug. Por que? Porque ele é um emulador e não um virtualizador. Dessa forma, você consegue ver as chamadas feitas ao hardware e manipular coisas que você não conseguiria manipular num virtualizador ou num computador real.

Direto da Wikipedia: “Num emulador, todos os recursos do sistema são processados nele (SIC) ao contrário da virtualização (SIC) que é uma ponte entre o hardware nativo e as chamadas do sistema operacional.”

Recomendo o Bochs de Windows, já que ele já vem compilado em sua última versão. Testei tanto pra OS X através do DarwinPorts, como pro Linux, mas a versão de Windows foi a que rodou mais tranquila. No Mac, o programa rodava extremamente lento, no Linux, tive diversos problemas durante a compilação para conseguir ativar o debuger. No Windows, foi só clicar duas vezes.

Achando a IDT e vendo a interrupção

Até então, vimos a parte teórica, relativamente fácil de entender… Conseguir achar isso na prática requer um pouco mais de paciência e ajuda do Jorjão (ou de um blog como esse, se você não conhece o Jorjão).

Para proteger o código apontado pela IDT, o x86 usa algumas artimanhas. Em vez de simplesmente apontar para o endereço da memória, ele utiliza uma base e um offset.

Para explicar melhor isso, vou usar o exemplo do trabalho sobre estouro de pilhas que fiz, e mostrar na prática o endereço usado pelo x86. Você pode ver na tabela acima que Stack-Segment Fault encontra-se na 12ª posição da IDT. Então pare a execução do Bochs (com CONTROL+C) e digite o seguinte na janela do do emulador (não na do sistema em andamento):

info idt 0xc

Saída do Bochs após o pedido de informação do IDT

Da resposta “Interrupt Gate target = 0×30:0x4b4” tiraremos duas informações que nos levarão ao endereço real apontado pela IDT.

O “0×30” é o 16 bit segment selector e o “0x4b4” o offset.

O segmente selector é dividido conforme a figura abaixo:

Divisão do segment selector

Portanto, a informação que procuramos está no GDT, na posição 6 (se você não entende como 12 virou c e 110 virou 6, estude um pouco sobre bases hexadecimal e binária)

Passe agora o seguinte comando para o Bochs:

info gdt 0x6

Saída do Bochs após o pedido de informação do GDT (Global Description Table)

O valor “0×1000” é o linear address, que usaremos junto ao offset para encontrar o endereço real de onde fica a rotina de interrupção.

Se você tiver um interesse masoquista por conhecimento, pode entender todas essas siglas e posições lendo os manuais da Intel que encontram-se aqui. É nele que toda essa loucura de proteção do endereço real é explicada.

Finalmente, com linear addres + offset, temos o endereço real, que é 0x14b4.

Para confirmar isso, digite o seguinte na janela de emulação do Bochs:

u 0x14b4

Saída do Bochs após o pedido de informação do endereço 0x14b4

A resposta é que na posição “0x14b4“, encontra-se “push 0x0c” em assembly. Para confirmar que esse é o início da rotina de interrupção de estouro de pilha do Minix, temos que olhar para dois arquivos:

kernel/mpx386.s e kernel/protect.h

No primeiro, na linha 457, vemos o seguinte comando em assembly: push STACK_FAULT_VECTOR e no segundo, na linha 58, #define STACK_FAULT_VECTOR  12 .

Juntando tudo, verificamos que estamos exatamente na posição de início do código que o Minix executará caso uma interrupção de estouro de pilha ocorra.

Se você quiser brincar um pouco e ver uma interrupção ocorrendo, pode inserir uma pausa no Bochs usando:

b 0x14b4

Com isso, caso PC aponte para 0x14b4, o emulador será pausado.

Agora faça um programa eternamente recursivo como o abaixo para ver a interrupção ocorrendo:

#include <stdio.h>
#include <stdlib.h>
void meChama(int i){
	printf("iteracao %d\n", i++);
	meChama(i);
}

int main (int argc, const char * argv[]) {
	printf("iteracao 1\n");
	meChama(1);
	return 0;
}

Salve, compile, execute e veja a mágica.

Breackpoint em 0x14b4 mostrando sua mágica

A imagem acima mostra o exato momento em que o código que trata a interrupção de estouro de pilha começa a ser executado. Isso ocorre no momento em que o programa recursivo começaria a destruir toda sua memória e o processador (no caso, o emulador do processador) grita “PARA TUDO!!!” pro Minix e este passa a lidar com a bucha!

Tudo isso pode ser visto também nessa apresentação do Prezi que fizemos sobre estouro de pilha, mas que dependeu do entendimento da IDT e de todo o caminho tortuoso para achar o endereço real apontado por ela.