Com a aquisição da Sun Microsystems pela Oracle, em janeiro de 2010, o rumo do desenvolvimento da plataforma Java, e de outros projetos open source antes patrocinados pela empresa adquirida, foi radicalmente alterado. Em linhas gerais, pode-se dizer que a Oracle subiu o tom com as comunidades e ecossistemas formados em torno daqueles projetos, levando-os a redefinir sua forma de colaboração. O fato mais notável decorrente dessa nova conjuntura, sem dúvidas, foi o surgimento da The Document Foundation, criada especificamente para gerir o LibreOffice, um fork do OpenOffice.org. A comunidade da suíte de escritório concluiu que não poderia continuar nos termos que a Oracle passou a impor, e preferiu iniciar um novo projeto, baseado no primeiro, mas sem esperar nada de Larry Ellison – nem patrocínio, muito menos ordens.

Em relação ao Java, a postura da Oracle foi ainda mais pedante. Acreditando que números de alta cifra (milhões de desenvolvedores e bilhões de dispositivos, segundo ela mesma) lhe conferem autoridade para tanto, a empresa arrogou para si – e somente para si – o direito de distribuir sua versão “proprietária” do Java, tanto o SDK (para desenvolvimento) o JRE (para executar as aplicações). Com isso, as inúmeras distribuições Linux ficam proibidas de distribuir o Java da Sun Oracle.

Num momento em que até a Microsoft, a partir do Windows 8, está adotando o conceito de app store no sistema operacional, é uma contratendência e tanto. A ideia, já adotada há anos pelas distros Linux e mais recentemente pelas plataformas móveis, é que o usuário não tenha que “correr atrás” das aplicações de que precisa, visitando inúmeros sites e fazendo downloads nem sempre confiáveis. Com as centrais de aplicativos, a instalação da solução está a um clique (ou dois, ou três…), dentro do próprio ambiente do SO. Nesse contexto, a Oracle obrigará quem precisar de sua versão do Java a visitar o respectivo site para baixá-lo. No mundo Linux, suspeito, só agirá assim quem realmente necessitar do Java “proprietário”.

A partir dessa (controversa) decisão, as distros passarão a entregar somente o OpenJDK/OpenJRE, a versão do Java 100% livre. O que muda com isso? Para o usuário médio, quase nada. O OpenJDK parece estar maduro o suficiente para a maioria dos usos. Desenvolvo em PHP utilizando Netbeans como IDE, e posso afirmar que o ambiente integrado funciona tão bem com o OpenJRE quanto era com o JRE proprietário.

Vale lembrar que a versão 7 da plataforma Java também já está disponível em implementação open source, e será padrão na próxima versão do Ubuntu, a Oneiric Ocelot (11.10), que será disponibilizada ainda este mês. Para aqueles que não quiserem ou não puderem esperar, é possível instalar o OpenJDK/OpenJRE no Natty utilizando um PPA, assim:

(No último comando, basta substituir openjdk-7-jre para instalar somente o JRE. Para instalar o código fonte, acrescente openjdk-7-source.)

Mas, por óbvio, nada é perfeito. Há aplicações (ou deveria eu escrever “internet banking de bancos brasileiros”?) que foram feitos com e somente para para o Java “proprietário”. Quem projeta e desenvolve essas soluções que ignoram o OpenJDK deve, agora, rever suas concepções. A alegação de suportar somente o Java da Oracle, no mais das vezes, é calcada nos termos “segurança” e “homologação”. Pode-se contra-argumentar que a Oracle, sentada sobre os impressionantes números que já citei, sente-se confortável o bastante para relegar as falhas de segurança da plataforma Java a segundo plano, não se empenhando em saná-las. Tanto é assim que a Fundação Mozilla está considerando seriamente desativar o plugin do Java nas próximas versões do Firefox. Isso sem mencionar as frequentes críticas que são feitas à arquitetura da plataforma, às quais a empresa parece não querer oferecer uma resposta à altura.

Por tudo isso, creio que poderemos ver, num médio prazo, o futuro do Java sendo decidido exclusivamente pela comunidade Java, num cisma semelhante àquele que deu origem à The Document Foundation. A chave para que isso aconteça é a adoção maciça do OpenJDK, entregue pelas distribuições Linux e, quiçá, pelos próprios desenvolvedores Java, em conjunto (bundled) com suas aplicações. Só assim, vendo diminuída sua base de usuários, a Oracle venha a sair de sua zona de conforto e mude de atitude.

Ubuntu Mono, 24pt

Ela tem caracterísiticas interessantes para os programadores, como o zero ponteado (para ser distinto do “O” maiúsculo), e é bastante compacta, de modo que a tela exibe mais linhas de código, comparada com outras fontes.

Ubuntu Mono no Netbeans

Ubuntu Mono no GEdit

Certamente, a variante monoespaçada virá como padrão na próxima versão do Ubuntu, a Oneiric Ocelot (11.10), que sairá do forno ainda esse mês. Para quem não aguenta esperar e usa Ubuntu ou distros derivadas pode instalar a nova versão da Ubuntu Mono mediante um PPA:

Já aqueles que usam outra distribuição (ou Windows , ou Mac ) pode baixar as fontes num pacote ZIP aqui.

Aproveitem!

	Google Chrome	Chromium	Observações
Logotipo	Colorido	Tons de azul
Relatório de falhas	Sim, se habilitado	Nenhum	Por favor, inclua rastreamento de erros com símbolos em ao relatar bugs, caso não tenha um relatório de falha
Métricas de uso	Sim, se habilitado	Não
Tags de vídeo e áudio	AAC, MP3, Vorbis e Theora	Vorbis e Theora por padrão	Varia de acordo com as distribuições: no Ubuntu, o Chromium vem com os dois formatos; no Fedora, o suporte é completamente removido
Adobe Flash	Plugin personalizado (não-livre) incluído no pacote	Suporta plugins NPAPI, inclusive o fornecido pela Adobe
Suporte a PDF	Plugin personalizado (não-livre) incluído no pacote	Baixa e exibe documentos usando o visualizador PDF do sistema	O plugin de PDF do Chrome usa código não-livre de terceiros; não existe nenhum plugin de PDF em software livre que suporte todos os recursos que gostaríamos (como o preenchimento de formulários).
Código	Testado pelos desenvolvedores	Modificado pelas distribuições	Modificações adicionais pelas distribuições têm sido uma contínua fonte de problemas para os usuários; ao relatar bugs, por favor inclua infomações sobre a distribuição
Isolamento de processos (sandbox)	Sempre habilitado	Pode estar desabilitado, dependendo do distribuidor	Ubuntu e Gentoo: sempre habilitado; alguns pacotes não oficiais do Slackware o removem!
Empacotamento	Um único deb/rpm	Depende da distribuição, às vezes dividido em diversas partes (dados de locale, inspetor, v8)	O Ubuntu disponibiliza l10n e o inspetor (opcional) e 2 conjuntos de codecs (1 obrigatório), seja para as compilações noturnas, para o canal de desenvolvimento ou para o canal beta, mas com os mesmos nomes de pacotes em cada canal
Perfil	Armazenado em ~/.config/google-chrome	Armazenado em ~/.config/chromium
Cache	Armazenado em ~/.cache/google-chrome	Armazenado ~/.cache/chromium
Garantia de qualidade	Novas versões são testadas antes de serem distribuídas aos usuários	Às vezes, compilações noturnas não testadas	Depende da distribuição: por exemplo, o Chromium do Ubuntu mantém os mesmos números de versão do Google Chrome, mas outras distribuições às vezes disponibilizam compilações “noturnas” instáveis

É notório que o quadro acima, apesar de pertencer à documentação do Chromium, foi escrito por alguém ligado ao Google. Além de destacar as vantagens do Chrome sobre seu irmão 100% livre, a comparação não deixa de fazer certo terrorismo quanto ao código “não testado” e “modificado pelas distribuições” do Chromium. Isso sem falar no ícone “azul sem graça” do Chromium .

Ideologias e mercadologias à parte, o Chrome é a escolha óbvia de quem prefere uma experiência de navegação na Internet out of the box, sem se preocupar com codecs, plugins e outros detalhes. Por outro lado, o Chromium é mais adequado àqueles que gostam de ter um controle maior sobre o que instalam, e aos ciosos de terem somente software livre em suas máquinas.

Concluindo, a escolha é sua .

Parece que muitas pessoas andam tentando fazer com que o WordPress e o Yii Framework trabalhem em conjunto. Eu me deparei com o mesmo problema, mas agora creio que o resolvi, após muito quebrar a cuca e gastar inúmeras horas de trabalho.

Meu ponto de partida foi a leitura dos artigos (em inglês) do imasia e do isekream. O princípio de ambas as pesquisas é chamar a aplicação Yii de dentro do WordPress. A solução que proponho coloca-se na mão contrária: utilizar o WordPress como modelo de página para a aplicação Yii, de modo que o usuário final nem perceberá que saiu do primeiro e foi parar na segunda.

Vamos em frente.

No WordPress

Minha instalação do WordPress usa um tema-filho do Twentyten (o padrão do WordPress 3.x). Para os efeitos deste tutorial, assumamos que nossa instalação do WordPress está em http://seuservidor.com.br/wp. Ao aplicá-lo, altere o caminho de acordo com sua situação.

O primeiro passo é criar um arquivo na pasta do seu tema do WP, e chamá-lo yii-template.php.

Arquivo: [raiz-wp]/wp-content/themes/[seutema]/yii-template.php

<?php
/**
 * Template Name: Yii Template
 *
 * Template for Yii-powered pages
 *
 * The "Template Name:" bit above allows this to be selectable
 * from a dropdown menu on the edit page screen.
 *
 * @package WordPress
 * @subpackage Twenty_Ten
 * @since Twenty Ten 1.0
 */
get_header();
?>
 
<div id="container">
  <div id="content" role="main">
 
    <?php
    /*
     * O marcador de lugar abaixo será substituído mais tarde pelo conteúdo gerado pelo Yii.
     */
    ?>
    <!-- ###yii-content-placeholder### -->
 
  </div><!-- #content -->
</div><!-- #container -->
 
<?php get_sidebar(); ?>
<?php get_footer(); ?>

Acabamos de criar um novo modelo para páginas do WordPress.

O passo seguinte é criar uma página no WordPress que use o modelo recém-criado. Acesse o painel administrativo do seu WP, crie uma página e selecione “Yii Template” (deve estar listado) como modelo da página. Informe yiipage no título e deixe o conteúdo da página em branco. Após salvar, você deverá ser capaz de ver a página usando o endereço http://seuservidor.com.br/wp/yiipage.

Isso é tudo o que tínhamos que fazer no WordPress.

No Yii

Crie uma aplicação Yii (usando yiic) sob a raiz da sua instalação do WP, numa pasta chamada yii. Você deverá ver a conhecida página inicial do Yii ao acessar http://seuservidor.com.br/wp/yii.

We’ll need a custom ClientScript class. Let’s create it under [yii-root]/protected/components.

Teremos que criar nossa própria classe ClientScript. Vamos fazê-lo sob  [raiz-yii]/protected/components.

Arquivo: [raiz-yii]/protected/components/ClientScript.php

<?php
 
class ClientScript extends CClientScript {
 
  public function renderHead(&$output) {
    $html = '';
    foreach ($this->metaTags as $meta) $html.=CHtml::metaTag($meta['content'], null, null, $meta) . "\n";
    foreach ($this->linkTags as $link) $html.=CHtml::linkTag(null, null, null, null, $link) . "\n";    
    foreach ($this->cssFiles as $url => $media) $html.=CHtml::cssFile($url, $media) . "\n";
    foreach ($this->css as $css) $html.=CHtml::css($css[0], $css[1]) . "\n";
    if ($this->enableJavaScript) {
      if (isset($this->scriptFiles[self::POS_HEAD])) {
        foreach ($this->scriptFiles[self::POS_HEAD] as $scriptFile) $html.=CHtml::scriptFile($scriptFile) . "\n";
      }

      if (isset($this->scripts[self::POS_HEAD])) $html.=CHtml::script(implode("\n", $this->scripts[self::POS_HEAD])) . "\n";
    }

    if ($html !== '') {
      $count = 0;
      /*
       * A linha abaixo garante que tudo o que for registrado pelo Yii no POS_HEAD irá imediatamente
       * antes do final do cabeçalho (). Dessa forma, os estilos e scripts do Yii serão
       * renderizados *ABAIXO* e *DEPOIS* daqueles do WordPress.
       *
       * A linha original na classe ancestral era assim:
       * $output = preg_replace('/(]*>|)/is', '$1', $output, 1, $count);
       *
       */
      $output = preg_replace('/()/is', '$1', $output, 1, $count);
      if ($count) $output = str_replace('', $html, $output);
      else $output=$html . $output;
    }
  }
 }
?>

Será necessário também sobrepor o método CController.beforeRender(). Isso pode ser feito no arquivo Controller.php, que já existe em [raiz-yii]/protected/components.

Arquivo: [raiz-yii]/protected/components/Controller.php

<?php
/**
 * Controller is the customized base controller class.
 * All controller classes for this application should extend from this base class.
 */
class Controller extends CController
{
    /**
     * @var string the default layout for the controller view. Defaults to '//layouts/column1',
     * meaning using a single column layout. See 'protected/views/layouts/column1.php'.
     */
    public $layout='//layouts/column1';
    /**
     * @var array context menu items. This property will be assigned to {@link CMenu::items}.
     */
    public $menu=array();
    /**
     * @var array the breadcrumbs of the current page. The value of this property will
     * be assigned to {@link CBreadcrumbs::links}. Please refer to {@link CBreadcrumbs::links}
     * for more details on how to specify this property.
     */
    public $breadcrumbs=array();
 
  protected function beforeRender($view) {
 
    /* 
     * Let's prevent Yii from registering jQuery library. We'll stick with
     * the jQuery registered by Wordpress.
    */
    Yii::app()->clientScript->scriptMap=array(
      'jquery.js'=>false,
      'jquery.min.js'=>false,
    );
    /*
     * O Wordpress trabalha com a jQuery no modo "sem-conflito", i. e., ele não define o apelido $
     * para o objeto jQuery. No entanto, muitos scripts e plugin do Yii supõem que $ aponta para a
     * jQuery, de modo que precisamos fazer essa associação nós mesmos.
     */
    if(! Yii::app()->clientScript->isScriptRegistered('jquery-alias', CClientScript::POS_HEAD)) {
      Yii::app()->clientScript->registerScript('jquery-alias', 'var $ = jQuery', CClientScript::POS_HEAD);
    }

    /*
     * Para manter a coerência visual entre as páginas comuns do Wordpress e aquelas turbinadas
     * pelo Yii, devemos utilizar o CSS fornecido pelo tema do Wordpress. Contudo, o Yii usa
     * algumas classes CSS específicas para formulários, então é uma boa ideia registrar o
     * arquivo que as contém.
     */
    Yii::app()->clientScript->registerCssFile(Yii::app()->request->baseUrl . '/css/form.css');

    return parent::beforeRender($view);
  }

}
?>

Agora, a pedra fundamental da ideia toda. Vamos alterar o arquivo principal do layout do Yii, para buscar a página do WordPress que preparamos previamente, e substituir o marcador de lugar pelo conteúdo gerado pelo framework.

Arquivo: [raiz-yii]/protected/views/layouts/main.php

<?php
  /*
   * Aqui reside o cerne da mágica. Ao invés de usar o HTML do arquivo principal de
   * layout fornecido pelo Yii, buscamos a página especial do Wordpress (como uma string)
   * e substituímos o marcador de lugar pelo conteúdo real.
   */

  echo str_replace('<!-- ###yii-content-placeholder### -->',
    $content, file_get_contents('http://seuservidor.com.br/wp/yiipage'));

  /* NÃO SE ESQUÇA DE APAGAR O CONTEÚDO DA PÁGINA ORIGINAL ;) */

?>

Por fim, vamos dizer ao Yii para usar nossa classe ClientScript personalizada.

Arquivo: [raiz-yii]/protected/config/main.php

<?php   
    (...)   'components'=-->array(
    /*
     * Vamos usar nosso próprio ClientScript (application.components.ClientScript).
     */
    'clientScript' => array(
      'class' => 'ClientScript'
    ),
  (...)
?>

E isso é tudo. Você deverá conseguir ver sua aplicação Yii com tema WordPress acessando http://seuservidor.com.br/wp/yii, e até mesmo fazer login mediante http://seuservidor.com.br/wp/yii/index.php?r=site/login. Adicionalmente, você pode ajustar sua configuração do Yii para usar URLs de caminho e ocultar o nome do script (assim, seus URLs se parecerão com http://seuservidor.com.br/wp/yii/controller/action). E sim, o AJAX funciona! *__*

De volta ao WordPress, a tarefa final é criar itens de menu (como links) apontando para as páginas turbinadas pelo Yii.

Espero que isto seja tão útil para você quanto foi para mim. Saudações!

O Ubuntu 11.04 (também conhecido pelo simpático e críptico codinome Natty Narwhal) já está aí, e, com ele, veio junto a nada unânime interface Unity. Ainda não tenho uma opinião fechada sobre ela, mas, tão logo a instalei (ou melhor: consegui fazê-la funcionar ), notei que ela levou a ideia de melhor aproveitamento do espaço da tela – algo que venho advogando, e não é de hoje – às últimas consequências. No meu ponto de vista, porém, o ganho de espaço útil trouxe consigo uma certa queda nos níveis de usabilidade.

Em face disso, fui em busca de ajustes na configuração para que ela satisfizesse minhas necessidades de usuário. E isso é o que eu gostaria de compartilhar com vocês neste post.

Instalando o pré-requisito

Para poder configurar o Unity, é necessário o aplicativo de Configurações Avançadas do Compiz. Parece que ele não faz parte de uma instalação padrão e limpa do Natty. Para instalá-lo, basta procurar por “Configurações avançadas de efeitos da área de trabalho (ccsm)” na Central de Programas do Ubuntu, ou, para os fãs de um velho e bom terminal, sudo apt-get install compizconfig-settings-manager.

Encontrando o aplicativo de configurações

Para encontrar as Configurações Avançadas do Compiz (CCSM, para encurtar), após a instalação, basta clicar sobre o botão do Ubuntu (canto superior esquerdo da tela), digitar “compiz” para efetuar uma busca e clicar sobre o ícone correspondente.

Encontrando as Configurações Avançadas do Compiz

Encontrando as configurações do Unity

O Unity é, na verdade, um plugin do Compiz. Para encontrar as configurações específicas dele no CCSM, digite “unity” na caixa de buscas e, uma vez mais, clique sobre o respectivo ícone.

Encontrando as configurações do Unity no CCSM

Os ajustes

Tornando o painel lateral permanentemente visível

O painel lateral do Unity, por padrão, esconde-se quando julga não ser útil ao usuário num dado momento. Se você, como eu, tem um monitor widescreen e fica “perdido” sem algo que lhe mostre quais janelas estão abertas, talvez queira que o painel lateral fique visível permanentemente. Para isso, escolha a opção “Never” na configuração “Hide launcher”.

Ajustando o painel lateral do Unity para visibilidade permanente

Distinguindo melhor os aplicativos abertos

Ficou confuso saber quais aplicativos estão abertos, observando o painel lateral? Podemos melhorar isso. Na aba “Experimental”, ajustemos “Backlight Mode” para “Backlight Toggles”. Dessa forma, aquela “luzinha colorida” que aparece por detrás dos ícones do painel só estará ativa para os aplicativos que estão sendo executados no momento.

Deixando a luz de fundo acesa só para os aplicativos abertos

Diminuindo o tamanho dos ícones

O tamanho padrão dos ícones do painel lateral é 48 pixels, dimensão pensada, certamente, para uso do Unity em dispositivos touchscreen, como tablets. Contudo, se o que você tem é um computador desktop ou mesmo um notebook, esse tamanho poderá parecerá exagerado – em especial se você optar por deixar o painel sempre visível. Também na aba “Experimental”, há o ajuste “Launcher icon size”, no qual eu coloquei o mínimo possível: 32 pixels. Sinceramente, eu acho que o tamanho mínimo poderia ser ainda menor, mas…

Querida, encolhi os ícones!

Um pouco de cosmética: deixando o painel superior (semi)transparente

É perfumaria, eu sei, mas eu acho bonitinho . Por padrão, o painel superior é 100% opaco, mas podemos alterar isso, ajustando o valor de “Panel Opacity” (na aba “Experimental”) para um valor menor que 1. Pessoalmente, gosto do efeito que 0,85 proporciona.

Transparência é sexy, não concorda?

Reabilitando a área de notificação para todas as aplicações

Você deve ter notado (ou não ) que a área de notificação (vulgo systray) do Natty está bem mais enxuta, e que muitas aplicações que davam as caras por lá não aparecem mais. Se isso é um problema para você, é possível voltar a permitir que qualquer aplicação volte a colocar seu ícone por lá. Dessa vez, deixaremos o CCSM de lado e vamos direto à linha de comando:

Será necessário encerrar a sessão e fazer login novamente para que a nova configuração tenha efeito. Esta última dica foi devidamente “chupinhada” do site WEB UPD8, aliás ótima referência sobre Ubuntu (e Linux, em geral), para quem arranha pelo menos um pouco de inglês.

Os ícones de volta à área de notificação. Entre eles, Pidgin e Dropbox.

Conclusão

O Unity é ótimo em sua intenção de proporcionar a maior área útil possível de tela. Se ele conseguirá fazer isso bem e conquistar a grande massa de usuários, só o tempo dirá. Se me permitem opinar, acho que a interface está num estado ainda beta, e não são poucos aqueles que relatam dificuldades em fazê-la funcionar – foi assim também comigo, o Unity não rodou out of the box, como prometido, apesar de minha placa nVIDIA GeForce 9800 GT. Mas vale, porque estamos experimentando um mundo novo, e o foco do Unity, inequivocadamente, é fazer a transição do mouse para o touchscreen o mais suave possível.

Não se assuste com o título desse post. Sim, sou eu falando (mal) da Microsoft.

Ontem, por dever de ofício, fui instalar o SQL Server 2008 em algumas máquinas de laboratório, para alunos de Sistemas de Informação. Em muitos equipamentos, logo após iniciar o setup.exe, deparei-me com esse pequeno poema:

"Invoke or BeginInvoke cannot be called on a control until the window handle has been created.." Microsoft e suas esclarecedoras mensagens de erro.

Tomei o caminho de Delfos e fui perguntar ao Grande Oráculo o que fazer. Dentre as várias respostas (enigmáticas) que recebi, uma delas recomendava baixar dois hotfixes, coisa de míseros 200 MB – que, não bastasse o tempo perdido aguardando o download terminar, não resolveram o problema.

Mas eu #SouDev e não desisto nunca. Continuei garimpando os resultados da busca, até que topei com esse post aqui, que propunha uma solução ridiculamente simples (para não dizer risível). Ei-la: ao iniciar a instalação do SQL Server 2008, surge uma pequena janela, semelhante a essa:

Podem xingá-la. A culpa da coisa toda é dela.

O erro que relatei acima é causado – pasmem! – pela falta de foco na janelinha acima. Ela se acha o centro do mundo, quer as atenções só para ela, de tal forma que, tão logo ela surja na tela, é necessário clicar sobre ela para focá-la. Fim. Ou quase isso: essa janela aparece umas três ou quatro vezes durante o processo de instalação, e em todas o procedimento do clique precisa ser repetido. Aliás, depois de algumas tentativas malsucedidas, passei até a mover um pouco a janelinha egoísta pela tela, para garantir que ela havia mesmo recebido o foco.

Ah, sim, depois disso ainda tive que responder uma pá de perguntas e preencher uma dezena de parâmetros, e esperar uma 4 horas para que a instalação se completasse…

Meu ambiente de trabalho. Não reparem a bagunça

1) Um Ubuntu altamente personalizado

Há cerca de um ano, encarei o desafio de abandonar o Windows como plataforma de desenvolvimento e usar Linux para esse propósito. Escolhi a distribuição Ubuntu, que já usava nos meus computadores pessoais e com a qual já estava familiarizado.

Como gosto de deixar as coisas bem do meu jeito, meu Ubuntu, ao menos visualmente, em nada se parece com uma instalação recém-feita desse sistema operacional. Entre as personalizações que costumo fazer na interface, estão:

• a troca do tema padrão (atualmente, uso o tema Orta com os ícones Faenza);
• a redução para apenas um painel, o inferior, e o utilização do Docky na parte superior da tela para lançamento de aplicativos;
• o applet Cardápio no lugar do tradicional menu do GNOME; e
• o applet Dockbarx em substituição à lista de janelas/tarefas.

Minha instalação corrente começou na versão Karmic Koala (9.10), foi atualizada para a Lucid Lynx (10.04 LTS) e, no momento, corresponde à versão mais atual do SO, Maverick Meerkat (10.10). Tudo isso sem precisar formatar, comprovando a estabilidade do ambiente. Um ano, três versões e tudo rodando redondo. Exceto, é claro, quando eu tento fazer alguma atualização bleeding edge e ferro alguma coisa – a maior vítima é o driver da placa de vídeo. Mas #SouDev e não desisto nunca, daqui a pouco ponho o sistema de volta pra funcionar.

2) Netbeans para desenvolvimento PHP

Sempre estive em busca do IDE perfeito e open source (ou, pelo menos, freeware) para desenvolver em PHP (havia até um post meu sobre isso numa rede do Ning, mas todo mundo sabe o que aconteceu…). A meu ver, o estado da arte em termos de ambiente integrada para essa linguagem ainda não foi atingido. Contudo, o Netbeans evoluiu rapidamente e é, nos dias atuais, o que mais se aproxima do Olimpo. Tem, como vantagens, o fato de ser open source, multiplataforma (ainda que “multiplataforma”, aqui, seja sinônimo de Java) e relativamente leve, consideradas as circunstâncias. Por outro lado, ser baseado em Java, após a aquisição da Sun pela Oracle, é algo no mínimo temerário. Não por acaso, aguardo ansiosamente que o KDevelop com suporte a PHP amadureça e se torne logo utilizável. Pelo que já vi deste último, vem coisa boa por aí.

Netbeans IDE 7.0 Beta

Quem estiver interessado no meu esquema (escuro) de cores para o Netbeans, pode baixá-lo aqui e importá-lo em Ferramentas > Opções > Importar (no canto inferior esquerdo do diálogo).

3) Wine, PlayOnLinux e Winetricks

Esta tríade de utilitários permite executar no Linux muitos programas da plataforma Windows. Se o Wine é uma camada de tradução das bibliotecas de runtime do Windows, o PlayOnLinux é um front-end que, por intermédio de scripts, automatiza a instalação de vários aplicativos comuns (algumas versões do Microsoft Office e do Photoshop, por exemplo), embora seu foco seja a instalação de jogos. Por seu turno, o Winetricks é um script que localiza, baixa e instala muitas das dependências mais recorrentes de programas Windows, como as fontes TrueType da Microsoft, os MDAC, os runtimes do Visual Basic e do Visual C++, etc.

PSPad editor rodando via Wine

Dessa forma, consigo trabalhar, no Ubuntu, com alguns bons programas feitos para a plataforma do Tio Bill, tais como o PSPad, o EMS SQL Manager 2010 for MySQL e o EMS SQL Manager 2008 for SQL Server.

4) Firefox com WebDeveloper Toolbar e outras extensões

Como desenvolvedor web, tenho um bom número de navegadores instalados (o Infernet Explorer roda na VM, veja mais abaixo). Meu navegador principal continua sendo o Firefox, porque muitas de suas extensões ainda não encontram paralelos para o Google Chrome – apesar de todos os predicados deste. Dentre as extensões que mais utilizo, estão a WebDeveloper Toolbar e a DownThemAll!. Um recurso nativo particularmente interessante do navegador, para mim, é o Console de Erros Javascript – pego muitos erros por ele, sem sequer precisar acionar o Firebug.

Firefox com WebDeveloper Toolbar em ação

5) VMWare Player

OK, esse não é open source, é só freeware. Trabalho uma Instituição de Ensino Superior com foco em Ciências Sociais Aplicadas, ou, traduzindo, o povo daqui adora uma planilha. E, para manter a compatibilidade, eu, o único linuxista dessas bandas, não posso viver só de OpenOffice.org. Necessito utilizar o Microsoft Office, versão 2010, adquirida pela Instituição e que (ainda) não consegui instalar via Wine. Há outras cositas também que me forçam a ter um ambiente Windows à disposição, como Photoshop, Delphi (para alguns sistemas legados) e Crystal Reports.

Durante muito tempo, deixei o VirtualBox , da Sun Oracle, encarregado das minhas máquinas virtuais. Sem embargo, dois fatores fizeram com que eu passasse a utilizar o VMWare Player: (1) este divide o disco virtual em vários arquivos, facilitando o processo de backup e (2) com ele, os efeitos visuais funcionam, ao contrário do que ocorria com o VirtualBox. Pode parecer frescura, mas, para mim, os efeitos visuais são fundamentais, principalmente quanto a testá-los em outras distros Linux e versões futuras do Ubuntu, coisa que faço com frequência. Além do mais, suspender e recuperar uma VM mostrou-se sensivelmente mais rápido no VMWare Player, relativamente ao VirtualBox.

VMWare Player rodando Windows 7

6) Gnome-RDP Remmina

UPDATE: seguindo o conselho do visitante BlueHood, expresso em seu comentário mais abaixo, acabei por trocar o Gnome-RDP pelo Remmina, até então desconhecido para mim. Vale a pena conhecê-lo! =D

Há muitos servidores rodando Windows Server aqui. E a rede toda é baseada no Active Directory. Felizmente, o Ubuntu conta com ferramentas para acesso remoto a máquinas Windows utilizando o protocolo RDP (mais conhecido por “Terminal Services”). O Gnome-RDP Remmina é simples, objetivo, e cumpre muito bem o seu papel, e ademais suporta também os protocolos VNC, SFTP e SSH. Para quem utiliza KDE, o utilitário equivalente é o KRDC.

O Remmina acessando um servidor Windows via Terminal Services

7) The Gimp

OK, OK, passo longe de ser um designer. Mas nem por isso estou livre de usar softwares de edição gráfica. Tenho o Photoshop instalado na VM, e <vergonha-propria mode="on"> desse programa sei utilizar menos de 1% do seu potencial </vergonha-propria>.

Quando a tarefa com imagens não é complexa o bastante para justificar a subida da VM à memória, faço uso do Gimp, sempre em Single-Window mode. Com ele, consigo fazer as coisas mais triviais, como redimensionamento e conversão de formatos, recortes e strokes. Enfim, no quesito “software gráfico” sou um mero principiante, em início de aprendizado, esperando absorver novas habilidades à medida que as necessidades surjam.

The Gimp e o meu papel de parede atual

Bonus track: Terminal + Guake

Nenhum desenvolvedor que se preze deve temer a linha de comando. Algumas tarefas (como, por exemplo, atualizar o Ubuntu) são muito mais simples via terminal. E o Guake, uma quase-unanimidade, torna a praticidade do terminal ainda mais prática, se é que me entendem. Após instalado e carregado, basta um F12 para que uma janela de terminal se descortine com elegância à frente de seus olhos.

O Guake trabalhando

Passando a bola adiante

Para manter o espírito do meme, passo a bola para o Francisco Prado (@fr_prado), o Henrique Lobo Weissmann (@loboweissmann), o Bruno Bemfica (@CodeAddicted) e o Fábio Vedovelli (@vedovelli). Compartilhem sua forma de trabalho, pessoal!

No meu último post, no qual tratei sobre normalização de nomes próprios, eu havia utilizado uma expressão regular para testar se determinada parte de um nome corresponde a um numeral romano. Antes de encontrar a expressão regular para fazer o teste, eu já estava quebrando a cabeça para escrever uma rotina para fazer a mesmíssima tarefa. Eis o que eu pensava em fazer:

• Testar se a substring continha apenas caracteres válidos para números romanos – no caso, ‘I’, ‘V’, ‘X’, ‘C’, ‘D’ e ‘M’. Essa era a parte fácil.
• Determinar se os ditos caracteres estavam na ordem e na quantidade corretas para representar um número romano válido – e era aí que a porca torcia o rabo.

Pelo meu método de raciocínio costumeiro, essa rotina teria alguns loops e outros tantos ifs, e, com certeza, não teria menos que dez linhas de código PHP. Ao pesquisar sobre a estrutura dos números romanos, deparei-me com a expressão regular que você pode observar na linha 18 da listagem daquele post (e que foi utilizada na linha 100). Com ela, resolvi meu problema em uma única linha.

Se eu havia sido esperto nessa parte do código, cometi uma sobrinhagem na parte em que eu precisava substituir todas os espaços duplos por espaços simples. Desde sempre, utilizei um laço para substituir todas as ocorrências de dois espaços por um único espaço, até que não houvesse mais nenhum daqueles. Desta forma:

<?php
while(mb_strpos($nome, self::NN_ESPACO_DUPLO) != false)
      $nome = mb_ereg_replace(self::NN_ESPACO_DUPLO, self::NN_ESPACO, $nome);

Isso funciona assim: se houver quatro espaços contíguos, na primeira passagem esses quatro tornar-se-ão dois. Somente na segunda passagem é que esses dois espaços serão reduzidos a apenas um, que é o resultado desejado. Quanto mais espaços contíguos, mais repetições serão necessárias.

E tudo isso se resolve, de forma muito mais elegante e eficiente, também com uma expressão regular, e em uma única instrução. E o melhor: independentemente da quantidade de espaços contíguos.

<?php
$nome = mb_ereg_replace('\s+', ' ', $nome);

A mágica reside na expressão regular \s+. O que ela significa? \s encontra espaços em branco, e o modificador + indica uma ou mais ocorrências. Era tudo o que eu precisava. E já corrigi o código do post anterior.

As expressões regulares, ao mesmo tempo que encantam com seu poder, também costumam assustar pela sua relativa complexidade. Antes de continuar, vale um definição do que são expressões regulares, provida pela Wikipédia:

Em ciência da computação, uma expressão regular (ou o estrangeirismo regex, abreviação do inglês regular expression) provê uma forma concisa e flexível de identificar cadeias de caracteres de interesse, como caracteres particulares, palavras ou padrões de caracteres. Expressões regulares são escritas numa linguagem formal que pode ser interpretada por um processador de expressão regular, um programa que ou serve um gerador de analisador sintático ou examina o texto e identifica partes que casam com a especificação dada.

Creio que isso esclarece (quase) tudo, mas vou colocar as coisas em termos mais práticos. A palavra regular provém do latim regula, -ae, que significa, ao mesmo tempo, regra e régua. Isso permite afirmar que as expressões regulares têm aplicação quando precisamos encontrar ou extrair ocorrências de caracteres de um texto, no qual ditos caracteres obedecem a determinados padrões (regra) e/ou se encontram em posições previsíveis (régua). E texto, nesse sentido, significa tanto um campo de número de telefone quanto uma cadeia com alguns milhares de caracteres.

Portanto, da próxima vez em que você precisar encontrar ou extrair determinadas substrings de um texto, e seu código começar a ficar mais complexo do que deveria, considere utilizar expressões regulares. Todas as linguagens importantes, hoje em dia, têm algum tipo de suporte a elas. É o tipo de conhecimento que vale o tempo em que se investe nele – uma hora gasta para aprendê-las pode poupar algumas de trabalho brabo .

Para aprender:

• Expressões regulares – guia de consulta rápida
• Portal brasileiro de expressões regulares
• Regular-Expressions.info (em inglês)
• regexpal – um testador de expressões regulares online (em inglês)
• LIVRO: “Mastering Regular Expressions”, da Editora O’Reilly (em inglês), sugestão do @loboweissmann. É possível comprar só o ebook

Vou tratar sobre normalização de nomes próprios. Norma… o quê?

O problema

Algo que sempre achei horroroso em bancos de dados é a falta de padrão na capitalização (uso de letras maiúsculas e minúsculas) em nomes próprios – sejam de pessoas, logradouros ou localidades. Sobrinhos, geralmente, gravam no BD esses dados como foram coletados ou digitados, e programadores preguiçosos, no mais das vezes, limitam-se a aplicar um strtoupper() ou equivalente e entopem o cadastro com LETRAS MAIÚSCULAS. Na sinceridade, não sei qual das duas situações deixa o banco mais feio. O uso indiscriminado de letras maiúsculas, vale lembrar, cansa os olhos e dificulta a leitura após um certo tempo.

Já vi um caso em que a “saída” foi o uso de ucfirst() puro e simples. Menos mau, mas tão indolente quanto.

Fazer uma normalização, transformando “JOSÉ DA SILVA PEREIRA E SOUZA” em “José da Silva Pereira e Souza” não é uma tarefa difícil, desde que o desenvolvedor esteja atento a alguns detalhes.

A solução

Criei uma classe com um método estático em PHP (para não fugir ao paradigma da orientação a objetos) para propor minha solução. Expliquei, tanto quanto pude, todas as etapas nos comentários do código. Trata-se, em última instância, da implementação de um algoritmo relativamente simples, que não deve oferecer dificuldades para ser portado para outras linguagens. Se você utiliza PHP, de agora em diante aplique GUtils::normalizarNome($nome) e tenha um cadastro mais bonitinho e legível! Se não, implemente a ideia em sua linguagem favorita.

<?php
/**
 * Classe contêiner para métodos estáticos de utilidades variadas
 *
 * @author goncin (goncin ARROBA gmail PONTO com)
 */
class GUtils {

  /**
   * Constantes definidas para melhor legibilidade do código. O prefixo NN_ indica que
   * seu uso está relacionado ao método público e estático normalizarNome().
   */
  const NN_PONTO = '\.';
  const NN_PONTO_ESPACO = '. ';
  const NN_ESPACO = ' ';
  const NN_REGEX_MULTIPLOS_ESPACOS = '\s+';
  const NN_REGEX_NUMERO_ROMANO =
    '^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$';

   /**
   * Normaliza o nome próprio dado, aplicando a capitalização correta de acordo
   * com as regras e exceções definidas no código.
   * POR UMA DECISÃO DE PROJETO, FORAM UTILIZADAS FUNÇÕES MULTIBYTE (MB_) SEMPRE
   * QUE POSSÍVEL, PARA GARANTIR SUA USABILIDADE EM STRINGS UNICODE.
   * @param string $nome O nome a ser normalizado
   * @return string O nome devidamente normalizado
   */
  public static function normalizarNome($nome) {

    /*
     * A primeira tarefa da normalização é lidar com partes do nome que
     * porventura estejam abreviadas,considerando-se para tanto a existência de
     * pontos finais (p. ex. JOÃO A. DA SILVA, onde "A." é uma parte abreviada).
     * Dado que mais à frente dividiremos o nome em partes tomando em
     * consideração o caracter de espaço (" "), precisamos garantir que haja um
     * espaço após o ponto. Fazemos isso substituindo todas as ocorrências do
     * ponto por uma sequência de ponto e espaço.
     */
    $nome = mb_ereg_replace(self::NN_PONTO, self::NN_PONTO_ESPACO, $nome);

    /*
     * O procedimento anterior, ou mesmo a digitação errônea, podem ter
     * introduzido espaços múltiplos entre as partes do nome, o que é totalmente
     * indesejado. Para corrigir essa questão, utilizamos uma substituição
     * baseada em expressão regular, a qual trocará todas as ocorrências de
     * espaços múltiplos por espaços simples.
     */
    $nome = mb_ereg_replace(self::NN_REGEX_MULTIPLOS_ESPACOS, self::NN_ESPACO,
      $nome);

    /*
     * Isso feito, podemos fazer a capitalização "bruta", deixando cada parte do
     * nome com a primeira letra maiúscula e as demais minúsculas. Assim,
     * JOÃO DA SILVA => João Da Silva.
     */
    $nome = mb_convert_case($nome, MB_CASE_TITLE, mb_detect_encoding($nome));

    /*
     * Nesse ponto, dividimos o nome em partes, para trabalhar com cada uma
     * delas separadamente.
     */
    $partesNome = mb_split(self::NN_ESPACO, $nome);

    /*
     * A seguir, são definidas as exceções à regra de capitalização. Como
     * sabemos, alguns conectivos e preposições da língua portuguesa e de outras
     * línguas jamais são utilizadas com a primeira letra maiúscula.
     * Essa lista de exceções baseia-se na minha experiência pessoal, e pode ser
     * adaptada, expandida ou mesmo reduzida conforme as necessidades de cada
     * caso.
     */
    $excecoes = array(
      'de', 'di', 'do', 'da', 'dos', 'das', 'dello', 'della',
      'dalla', 'dal', 'del', 'e', 'em', 'na', 'no', 'nas', 'nos', 'van', 'von',
      'y'
    );

    for($i = 0; $i < count($partesNome); ++$i) {

      /*
       * Verificamos cada parte do nome contra a lista de exceções. Caso haja
       * correspondência, a parte do nome em questão é convertida para letras
       * minúsculas.
       */
      foreach($excecoes as $excecao)
        if(mb_strtolower($partesNome[$i]) == mb_strtolower($excecao))
          $partesNome[$i] = $excecao;

      /*
       * Uma situação rara em nomes de pessoas, mas bastante comum em nomes de
       * logradouros, é a presença de numerais romanos, os quais, como é sabido,
       * são utilizados em letras MAIÚSCULAS.
       * No site
       * http://htmlcoderhelper.com/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression/,
       * encontrei uma expressão regular para a identificação dos ditos
       * numerais. Com isso, basta testar se há uma correspondência e, em caso
       * positivo, passar a parte do nome para MAIÚSCULAS. Assim, o que antes
       * era "Av. Papa João Xxiii" passa para "Av. Papa João XXIII".
       */
      if(mb_ereg_match(self::NN_REGEX_NUMERO_ROMANO,
        mb_strtoupper($partesNome[$i])))
        $partesNome[$i] = mb_strtoupper($partesNome[$i]);
    }

    /*
     * Finalmente, basta juntar novamente todas as partes do nome, colocando um
     * espaço entre elas.
     */
    return implode(self::NN_ESPACO, $partesNome);

  }

}

O caso

Estava eu trabalhando num hotsite para um congresso internacional. Uma outra pessoa fez todo o layout e as páginas informativas, tendo ficado por minha conta desenvolver o processo de inscrição dos participantes.

O problema

O layout e as páginas informativas foram feitas em ASP (clássico), e eu vou desenvolver o procedimento de inscrição em PHP. As páginas da inscrição devem seguir o look and feel das demais páginas, aproveitando cabeçalho, rodapé e menus.

A solução

No código-fonte ASP, havia três includes:

<!--#include file="cabecalho.asp"-->
(...)
<!--#include file="menu.asp"-->
(...)
<!--#include file="rodape.asp"-->

Para não ter de refazer em PHP esses três arquivos, que, aliás, estavam alocados em outro servidor, achei por bem pegar o conteúdo deles, já devidamente processados, e injetá-los no layout para ser usado com PHP. Assim, esses três includes transformaram-se em:

<?php echo file_get_contents('http://servidor/caminho/cabecalho.asp'); ?>
(...)
<?php echo file_get_contents('http://servidor/caminho/menu.asp'); ?>
(...)
<?php echo file_get_contents('http://servidor/caminho/rodape.asp'); ?>

Funcionou, foi uma boa sacada, mas isso resolvia apenas parte do problema. Como os arquivos incluídos estavam em outro servidor em relação ao meu script PHP, os hiperlinks e os caminhos para as imagens ficaram quebrados. Foi necessário incluir o caminho para o servidor nas tags a e image. Nada que um str_replace não dê jeito.

<?php
  $include = file_get_contents('http://servidor/caminho/cabecalho.asp');
  $include = str_replace(array('src="', 'href="'),
    array('src="http://servidor/caminho/', 'href="http://servidor/caminho/') , $include);
  echo $include;
?>
(...)
<?php
  $include = file_get_contents('http://servidor/caminho/menu.asp');
  $include = str_replace(array('src="', 'href="'),
    array('src="http://servidor/caminho/', 'href="http://servidor/caminho/') , $include);
  echo $include;
?>
(...)
<?php
  $include = file_get_contents('http://servidor/caminho/rodape.asp');
  $include = str_replace(array('src="', 'href="'),
    array('src="http://servidor/caminho/', 'href="http://servidor/caminho/') , $include);
  echo $include;
?>

E voilà! Tudo funcionando, sem precisar reimplementar do zero o layout em PHP. Agora posso me concentrar apenas em gerar o conteúdo.