Ganhei mais 6 convites para o GMail. Se alguém quiser algum me avise.

Lendo uma entrevista do Linus Torvalds publicada hoje achei alguma passagens legais:
“If I have a hero, it would have to be Sir Isaac Newton, partly because he’s unquestionably one of the most influential scientists who ever lived, but perhaps more importantly because of a quote he is famous for: “If I have been able to see farther, it was only because I stood on the shoulders of giants.” [...] I think that quote is what personifies science. And open source. [...] To invent something totally new and different just because you want to do something new and different is in my opinion, the height of stupidity and hubris.”
É interessante essa idéia de que nem sempre é preciso inventar algo totalmente novo mas somente melhorar as coisas que existem. Esse é um dos motivos do Linux ter avançado tanto. Vou pensar nisso quando começar a procurar um assunto pra minha dissertação de mestrado…
Outra frase legal é :”The less I have to do with customers, the better”. Eu concordo…

Ultimamente tenho estudado bastante sobre Web Services. O motivo por esse interesse é meu interesse sobre Grid Computing. A versão 3 do Globus Toolkit (GT3) é baseada no conceito de Grid Services, ou seja, os recursos do Grid são acessíveis na forma de serviços. Para entender melhor como funciona a teoria por trás dos Web Services estou lendo um excelente livro, o Professional Java Web Services, da Wrox. Também fiz alguns testes para ver como funciona o esquema. Vou tentar aqui colocar algumas coisas que fiz. Pode ser que auxilie alguém a começar os estudos, como está me ajudando.
O Serviço
Para iniciar os testes eu fiz um pequeno programa em Java que será meu primeiro Web Service. O código é:

import java.util.*;
public class CalcService {
public int add(int p1, int p2) {

return p1 + p2;
}

public int subtract(int p1, int p2) {

return p1 - p2;
}
}
Publicando o serviço
Para que o serviço possa ser acessado ele precisa ser publicado em algum servidor de aplicações. Neste caso eu escolhi o Tomcat, desenvolvido pela Apache Foundation. Fiz o download dos binários(4.1) no site http://jakarta.apache.org/ e descompactei no /usr/local/tomcat
O próximo passo é adicionar o suporte ao protocolo SOAP no Tomcat. O SOAP é o protocolo com o qual o Web Service será acessado e é padronizado pela W3C. Para fazer isso fiz o download do pacote (2.3.1) no site http://www.apache.org/dyn/closer.cgi/ws/soap/. Depois de descompactado é preciso copiar o arquivo soap-2_3_1/webapps/soap.war para o diretório de applicativos do Tomcat (cp soap-2_3_1/webapps/soap.war /usr/local/tomcat/webapps). Para testar se funcionou a instalação é só acessar o endereço http://localhost:8080/soap/
Para realizar a publicação é necessário primeiro criar um arquivo de definição no padrão WSDL. É um arquivo xml usado para definir a interface do Web Service. O arquivo que usei para esse teste foi:

<isd :service xmlns:isd="http://xml.apache.org/xml-soap/deployment" id="urn:onjavaserver">
<isd :provider type="java" scope="Application" methods="add subtract">
<isd :java class="CalcService"/>
</isd>
<isd :faultListener>org.apache.soap.server.DOMFaultListener</isd>
</isd>

Para realizar o deploy é só executar o comando:
java -classpath soap-2_3_1/lib/soap.jar:/usr/local/tomcat/common/lib/mail.jar:/usr/local/tomcat/common/lib/activation.jar org.apache.soap.server.ServiceManagerClient http://localhost:8080/soap/servlet/rpcrouter deploy DeploymentDescriptor.xml

Para visualizar se o deploy funcionou pode-se usar a interface de administração do SOAP:
http://localhost:8080/soap/admin/index.html
Na opção List é possível ver os serviços.
O próximo passo é copiar o CalcService.class para o diretório de classes do soap para que o servidor de aplicações possa executar. :

cp CalcService.class /usr/local/tomcat/webapps/soap/WEB-INF/classes/

Os clientes
Para realizar os testes fiz tres pequenos clientes para “consumir” o serviço.
O primeiro, em Java:

import java.io.*;
import java.net.*;
import java.util.*;
import org.apache.soap.*;
import org.apache.soap.rpc.*;

public class CalcClient {

public static void main(String[] args) throws Exception {

URL url = new URL (”http://localhost:8080/soap/servlet/rpcrouter”);

Integer p1 = new Integer(args[1]);
Integer p2 = new Integer(args[2]);

// Constroi a chamada.
Call call = new Call();
call.setTargetObjectURI(”urn:onjavaserver”);
call.setMethodName(args[0]);
call.setEncodingStyleURI(Constants.NS_URI_SOAP_ENC);
Vector params = new Vector();
params.addElement(new Parameter(”p1″, Integer.class, p1, null));
params.addElement(new Parameter(”p2″, Integer.class, p2, null));
call.setParams (params);

// faz a chamada
Response resp = call.invoke(url, “” );
Parameter result = resp.getReturnValue();
System.out.println(args[0]+”=”+result.getValue());
}
}

O resultado da execução:

elm@elm:~/documentos/soap $ java CalcClient subtract 5 1
subtract=4
elm@elm:~/documentos/soap $ java CalcClient add 5 1
add=6

A segunda versão do cliente, em PHP:

include("SOAP/Client.php");

$soapclient = new SOAP_Client(’http://localhost:8080/soap/servlet/rpcrouter’);
$soapoptions = array(’namespace’ => ‘urn:onjavaserver’,'trace’ => 0);
//chamando a função add
$ret = $soapclient->call(’add’, $params = array(1,2), $soapoptions);

if (PEAR::isError($ret))
{ // tratamento de erros
}
else
{
echo “Add=”.$ret;
}
//chamando a função substract
$ret = $soapclient->call(’subtract’, $params = array(10,2), $soapoptions);

if (PEAR::isError($ret))
{ // tratamento de erros
}
else
{
echo “Subtract=”.$ret;
}
E o terceiro, em python:

#cliente python usando servico feito em java rodando em servidor tomcat
from SOAPpy import SOAPProxy
server = SOAPProxy('http://127.0.0.1:8080/soap/servlet/rpcrouter')
print '2 + 2 = ' + str(server._ns("urn:onjavaserver").add(2,2))
print '5 - 2 = ' + str(server._ns("urn:onjavaserver").subtract(5,2))

A funcionalidade dos três é a mesma, mas o tamanho do código é interessante. O código em python é muito menor e mais fácil de se entender, IMHO.
Esses foram apenas alguns testes que fiz para tentar entender o funcionamento dos Web Services.

Semanas atrás comprei um notebook novo (um Toshiba M35X-s309) e estava em busca de uma distribuição de desktop para ele.
Primeiro testei o Conectiva 10. Não reconheceu minha tela widescreen nem a interface wireless. Com algumas modificações funcionou legal, mas ainda não era o q eu queria.
Depois testei o Suse 9.1. Também não reconheceu minha configuração de vídeo e wireless.
Resolvi então testar uma nova distribuição de que tinha ouvido falar muito bem, a Ubuntu Linux. Uma distro baseada no Debian, com um CD de instalação apenas e com o Gnome 2.8 como desktop padrão. Queimei o cd e curti muito. Algumas coisas que observei:
Instalação
Apesar de ser baseada em “modo texto” é uma das instalações mais fáceis de se realizar. As telas são altamente explicativas. As traduções para o português estão muito bem feitas (ponto pra comunidade brasileira), todo meu hardware foi reconhecido, inclusive a tela wide e a interface wireless, a instalação do grub também é tranquila, reconhecendo o outro sistema operacional instalado e configurando tudo que foi preciso. Não há muita opção de escolha de pacotes, mas como a distribuição é voltada para o usuário desktop isso é um ponto a mais.
Desktop
Como qualquer distro voltada ao desktop que se preze, a inicialização termina no GDM, para que seja escolhido um usuário a ser usado. Nessa tela já dá para começar a perceber o capricho dado aos acabamentos. O Gnome 2.8 está muito bom. Muito estável e bem acabado, realmente é um dos desktops mais polidos que já vi no Linux. O automont de dispositivos como pendrives e cd-roms está perfeito, dando realmente a transparência que o usuário final gostaria. Quanto ao Nautilus, ele vem configurado para agir no “modo spatial” (cada diretório é aberto em uma nova janela). Confesso que a princípio não era muito fã desta abordagem, mas após algumas horas de uso você acaba acostumando-se e gostando.
Aplicativos
A instalação inicial conta com tudo o que um usuário precisa.O OpenOffice 1.1.2 também muito bem acabado, com ícones e fontes bem configuradas, o Evolution 2.0.2, o Firefox 0.93, Gaim 1.0, Gimp 2.0.2, etc. Somente faz falta o suporte aos arquivos mp3 nos aplicativos como o Rhythmbox, o que é facilmente resolvido instalando alguns plugins. A configuração de vários aspectos do sistema é feita pelas Gnome System Tools, muito úteis e fáceis de usar.
Sistema
Como falei, uma das vantagens do Ubuntu é ser baseado no Debian, contando assim com uma vasta comunidade de programadores e com uma grande quantia de pacotes. Com alguns comandos é possível instalar qualquer pacote disponível nos mirrors do Ubuntu.

Na minha opinião, o Ubuntu resolve aquele velho dilema dos usuários do Debian, usar a versão estável com pacotes antigos ou usar a versão em desenvolvimento, com pacotes mais recentes, mas não tão estável e sujeita a pequenos problemas. O Ubuntu possui os pacotes mais recentes e ainda sim a equipe de desenvolvimento presa muito pela estabilidade e qualidade do sistema. Se depender de mim essa é uma distribuição que veio pra ficar e vai ganhar muitos novos adeptos.

Estava ficando muito complicado de usar o mini-sistema que tinha desenvolvido para postar os textos por aqui. Então decidi parar de querer reinventar a roda e migrei para um sistema mais completo, o Wordpress