webservcga

The end!

2005-12-28T19:51:00.000Z

Já algum que estava para colocar aqui este post.
A partir deste momento declaro encerrado este blog até algum motivo especial o faça. A apresentação teve lugar no passado dia 14 e terminei com a classificação de 16 valores. Ficou fora das minhas expectativas, porque contava ter pelo menos 18 para conseguir atingir média de 13. Sendo assim, devo ter ficado muito perco dos 12,5, mas não o suficiente para permitir o arredondamento para mais uma unidade.
A apresentação propriamente não correu pelo melhor, visto que ficou muito longa e passou do tempo predefinido, que consistia em 20 minutos. Entrei a todo o gás na apresentação e não consegui concluír toda a apresentação dentro do tempo pré-estabelecido, de modo que quando fui advertido que tinha excedido o tempo, fui obrigado a expôr tudo o resto de seguida.
Durante a discussão, não fui capaz de responder às questões colocadas, de modo que tudo se reflecte na classificação final obtida.
Acabou a minha vida de estudante universitário, vou iniciar uma nova fase na minha vida...

Data de apresentação e discussão

2005-12-09T14:57:00.000Z

Quem estiver interessado a estar presente na apresentação do meu projecto de fim de curso de Informática - Ramo Tecnológico, na Universidade do Algarve, esta vai ter lugar no próximo dia 14 de Dezembro, 4ª Feira, às 10h00 da manhã na sala 2.21 do Complexo Pedagógico do Campus de Gambelas. O tema do meu projecto intitula-se "Processamento distribuído do algoritmo Genético compacto através de Web Services" e foi orientado pelo prof. Fernando Lobo. Para além do orientador, irão integrar o júri de discussão os prof. Patrício Serendero, como director de curso e o prof. José Valente de Oliveira, na qualidade de arguente.

Já terminou !

2005-12-01T18:08:00.000Z

Na realidade ainda não! Mas estive toda a semana de volta do relatório porque era obrigatório de acordo com o regulamento de estágios e projectos proceder à entrega de toda e qualquer documentação necessário para a discussão do projecto até ao dia de ontem. O relatório foi uma chatice, como sempre, mas tinha de ser! Ao todo fiquei quase duas semanas de volta do dito cujo, escrevendo, escrevendo, até me fartar! Mas não podia-me fartar, por que tinha de ser! Após muitas horas de desgaste, litros de café, e noites mal dormidas, lá consegui pôr a versão definitiva nas mãos do meu orientador, sob a forma de três cópias para cada um dos membros do júri que vão assistir à apresentação oral do projecto, a combinar em princípio para um dia entre 12 e 15 de Dezembro, sendo este o último dia possível, porque é a data final para a notar ser lançada nos serviços académicos.
Após cerca de cinco meses de esforço contínuo em volta deste tema, mesmo assim muita coisa ficou por concretizar, como a ideia original de distribuir o algoritmo através da Internet através de um cliente que fosse atractivo tipo um applet de java, que era o mais provável, ou um screensaver como a ideia original do seti@home. Isto devido à altura tardia em que iniciei o projecto, depois ter andado durante um ano inteiro com seis disciplinas mais chatas, que se não as tivesse à perna, teria investido muito mais tempo naquilo que realmente interessava. O relatório foi todo escrito usando LaTeX, uma linguagem de processamento gráfico para a elaboração de documentos para publicações científicas. Foi fixe aprender LaTeX, mas depois de o ter experimentado, confesso que não morri de amores por ele, apesar de ser verdade que cumpre aquilo que promete. Algumas coisas chateam, como por exemplo páginas apenas com uma linha, fazer quadros com pseudo-código é impossível porque não faço ideia como modificar o tipo de letra predifinido para código, entre muitas outras coisas que só muito mais tempo de "mexeriquice" com o LaTex me iria dar.
Fazer um applet ou um screensaver teria sido uma coisa gira, mas assim não sucedeu. Em vez de usar a Internet, lá tive que me desenrascar com as threads de Java para ter um efeito semelhante ao de ter multiplos computadores ligados a colaborar no algoritmo!
Mas o que foi foi, e já não se pode fazer nada para o alterar. Deixo aqui uma versão do relatório para quem estiver interessado em consultá-la.
Agora as boas notícias, abri uma conta no Sourceforge, o conhecido sistema de apoio a projectos OpenSource, e agora sou mais um! Vou colocar lá o código todo, e se tiver tempo no futuro, prometo continuar aquilo que eu não consegui concretizar nos cinco meses findos. O endereço da nova casa do WebServCGA é

webservcga.sf.net

.
Provisoriamete, também, mas não deve ficar lá muito tempo vou disponbilizar na minha área pessoal da universidade a mesma informação.

Últimos resultados

2005-11-21T19:13:00.000Z

Aqui vão os últimos resultados disponíveis do meu projecto. Os gráficos foram elaborados com o GnuPlot e estão aproximadamente na mesma escala que os gráficos do artigo sobre a paralelização. Os meus resultados parecem confirmar em tudo os gráficos do artigo. A silhueta do traçado é em quase tudo semelhante, mesmo com um número menor de execuções (+-10 no meu projecto, 30 no artigo).
Aqui vão os gráficos dos resultados, conjuntamente com os gráficos do artigo original, para uma comparação directa:

NÚMEROS DE CÁLCULOS DE FITNESS POR THREAD

Resultados do projecto

Resultados do artigo

COMUNICAÇÕES POR THREAD

Resultados do projecto

Resultados do artigo

Eles aí estão, quentinhos...

2005-11-07T00:50:00.000Z

Acabei de pôr à prova o meu programa, e para isso durante todo este fim-de-semana usei o computador Gazela no laboratório de projectos da Universidade, mais o computador Girafa. O Gazela, uma vez que tem um processador rápido (AMD Athlon 1800+) com 768 MB de RAM era o candidato óbvio para correr o cliente, devido a ficar encarregue de fazer "todo o trabalho" de desenvolvimentos dos indivíduos, a sua avaliação e competição. O servidor, ao contrário do que é usual, era somente passivo nesta questão, uma vez que o seu trabalho era simplesmente receber as diferenças do último vector população e actualizá-lo, verificando se entretanto não teria convergido. Com apenas 192 MB de RAM, também não era preciso muito, apesar do servidor de JSP Tomcat ser um bocado pesado, já que, sendo uma aplicação concebida em JAVA, que é um devorador de recursos em qualquer máquina.
Mas o que importa é que, depois de uma série de contratempos e de ter tentado pôr o meu trabalho a usar a Internet "a sério", com o servidor no meu servidor/gateway Linux caseiro a fazer de servidor, e uma máquina qualquer na Universidade a fazer de cliente, podia ter uma aproximação mais próxima da realidade, se é que alguma vez o meu trabalho venha a ser usado na Internet, tenho esperanças de que sim :).
Enfim, vamos mas ao que interessa, aqui estão os gráficos das experiências que fiz durante o fim de semana. Segui quase à risca as mesmas condições do artigo Referência fundamental para o projecto : Lobo F. G., Lima C. F. & Mártires H. (2004). An Architecture for Massive Parallelization of the Compact Genetic Algorithm. (PDF) na página 8, e experimentei combinações de valores de m (máximo de execuções da função de fitness entre cada comunicação com o servidor) no intervalo {8,80,800,8000,80000} com números de threads (equivalente a processadores) no intervalo {1,2,4,8,16,32,64}. O artigo tem gráficos que vão até 1028, mas como a partir de 64, os gastos de RAM dispendida para a criação de threads são enormes, decidi deixá-los para outra ocasião. Os resultados apresentados resultam da média calculada da execução de 6 experiências para todas as combinações possíveis aos pares entre os valores dos dois intervalos. Excepto para m=8, em que a execução do cliente é extremamente demorada para poder obter um número de experiências em tempo útil. Para ter uma ideia do que tou a falar, a execução do cliente com m=8 mesmo com 64 threads precisou de 7550 segundos (um pouco mais de 2 horas) para se poder completar. Para este caso, apenas procedi (por enquanto) apenas a uma 1 execução para cada valor de threads possíveis no intervalo indicado.
Aqui estão os gráficos, elaborados com a ajuda do Excel, precedido do respectivo gráfico do artigo supracitado, cujos resultados pretende reproduzir:

NÚMEROS DE CÁLCULOS DE FITNESS POR THREAD

COMUNICAÇÕES POR THREAD

Não pretendo ficar por aqui, pretendo pelo menos completar a metade direita do gráfico que ficou de fora assinalada pelo quadrado colorido, se tiver a gana, mas também o hardware para poder fazer isso. Fiquem a aguardar as notícias dos próximos capítulos :)
P.S.:Estes não são os gráficos definitivos que pretendo colocar no relatório.

Agora já bate tudo certo (ou quase...)

2005-10-01T17:08:00.000+01:00

Depois de, na semana passada, os resultados experimentais do cGA que eu implementei não parecerem estar muito famosos, eis que agora, não sei bem como, tudo está conforme (aproximadamente) o que seria de esperar. Também é verdade que agora os resultados que apresento como gráficos no Excel foram feitos usando a média aritmética dos valores obtidos em 30 execuções do algoritmo, usando uma vez mais, como teste, a aplicação de usar uma função de trap's múltiplos concatenados.
O único senão é no total de cálculo da função de fitness, os resultados excedem ligeiramente os resultados apresentados no artigo citado. Mas, mesmo assim, de resto, todos os resultados são bastante satisfatórios. Os melhores são os que registam o número de building blocks no fim do algoritmo, o troço do gráfico segue quase a par os dos gráficos do artigo. Para além disso, de salientar que desta vez experimentar também com populações de 100 e 200, para ver como o algoritmo progride para pequenas alterações nesta gama de valores. E de facto, nota-se, quer tanto para s=4 e s=8 (s é a pressão de selecção), uma pequena subida quando se passa de popsize=8 para popsize=100 (popsize é o tamanho da população). O que não seria possível de verificar se não tivesse experimentado com esses valores.
Não consigo perceber a razão para os resultados agora estarem com esta qualidade, a única alteração que fiz no código foi na parte para seleccionar o melhor indivíduo, e estava relacionado com uma variável (que guarda o melhor fitness até o momento dentro de um loop que percorre todos os indivíduos gerados dentro de um array) em vez de ser inicializada com zero com estava dantes, passou a ser feita com menos infinito (ou melhor, o valor de Double.NEGATIVE_INFINITY ), e para além disso, estive a documentar o código todo com javadoc's e não me parece que fossem os comentários que fizessem com que o compilador percebesse também melhor o código :)
Aqui ficam os resultados obtidos:

Implementação não muito famosa

2005-09-28T18:36:00.000+01:00

Estive a experimentar a implementar a função de multiplos traps concatenados para diferentes valores da pressão de selecção. Os resultados ficaram aquém dos que se encontram no artigo do cGA. Os gráficos abaixo foram gerados com o auxílio do GNUPlot. Ambos os gráficos indicam o número de vezes que o fitness foi calculado até atingir a convergência, em função de vários valores para o tamanho da população (experimentei 8,500,1000,1500,2000,2500 e 3000 como vinha no artigo). Em ambos os casos o número de vezes ultrapassa largamente aquele que se encontra no artigo. Estava também para mostrar os resultados para s=2, mas a minha implementação do cGA nem sequer termina dentro de tempo útil, não foi possível determinar um gráfico.

TOTAL DE CÁLCULOS DE FITNESS

S=4

S=8

Elaborei também gráficos para a quantidade de "building blocks" completos que aparecem na solução final. E os resultados também estão muito longe de satisfazer.

NÚMERO DE "BUILDING BLOCKS" CORRECTOS OBTIDOS

s=4

s=8

Vai indo tudo nos eixos...

2005-09-11T22:17:00.000+01:00

Enfim, o projecto tem vindo a evoluir perfeitamente dentro dos eixos: desenvolvi um cliente de WS que lança varias threads, sendo possível assim simular um efeito parecido ao caso real em que pudessemos ter muitos clientes a correr em máquinas diferentes em simultâneo. Como não tenho possibilidades (nem remotas) de poder vir a testar o trabalho em semelhantes condições, as threads em Java, servem perfeitamente para esse efeito.E o JAVA, como linguagem recente que é, já suporta threading de raíz, e assim, em vez de termos um único programa, que segue a sequência predeterminada das linhas do código, é possível termos diferentes cópias do mesmo programa, a correrem como que ao mesmo tempo (como o meu portátil só tem um processador, o multiprocessamento real é ilusório). Assim, pus várias threads a descarregar o vector população do WS, usando a função já conhecida DownloadPopulationVector. Quando o trabalho é completado ao fim do número de iterações especificado pelo WS, o vector é transmitido "de volta" ao WS, que assim actualiza o vector população que detém para o último que lhe foi transmitido pelo último cliente (que neste caso é uma thread). Os testes que fiz foram muito simples, usando sempre a função One-Max, testei até ao máximo de 3 threads, com um limite de 5 e 10 iterações entre ciclos envio/pedido do vector população. Fiz algumas experiências, incluindo colocar cada thread a arrancar depois de outra com um intervalo de dois segundos entre lançamentos sucessivos e os resultados estão perfeitamente dentro do esperado. Andei a variar o tamanho da população e o comprimento da população por forma a aumentar o tempo que leva para resolvar o problema. Mas como a função é a one-max, é extremamente simples de resolver. Penso que o trabalho só deverá começar a dar resultados úteis a partir do momento em que deverei começar a aplicação o algoritmo genético compacto a algum tipo de aplicação em que o tempo dispendido no cálculo da função de avaliação (em inglês, fitness) seja de tal forma oneroso que faça com que valha realmente a pena usar o resultado destre trabalho para algo de interesse no futuro.Começam é a surgir na minha mente algumas questões que realmente devem importar como por exemplo:

uma sugestão dada pelo artigo que estou a seguir na implementação refere que o vector, depois de processado, deve ser reenviado de volta à fonte apenas com as diferenças entre o vector original e o novo prestes a ser enviado. Ora pessoalmente em que consiste fazer a diferença entre o novo vector e o antigo em termos de tamanho ? Como a estrutura de dados que estou a usar é basicamente um array, de que forma codifico as diferenças entre dois arrays? De certeza não será enviando apenas as diferenças literalmente entre as posições do vector população que viram o seu valor de frequência ser alterado. Um exemplo para clarificar aquilo que estou a pensar:
Suponhamos que originalmente o cliente descarrega do Web Service o seguinte vector população, correspondente a um problema em que se um cromossoma de cinco posições para uma população total de 20 elementos:
10;10;10;10;10

O cliente então começa a correr o algoritmo para um problema qualquer, que pode ser o one-max, e depois, ao terminar o número de iterações requerido envia o vector já com este aspecto:
10;14;16;12;10

A diferença "literal", posição a posição, entre os dois seria:

0;4;6;2;0

Em termos de memória, o efeito ganho em usar semelhante representação é nulo, de forma que, enviar o vector população só com as diferenças ou tal e qual como está, vai acabar por dar na mesma.

Outra forma de resolver o problema anterior seria enviar apenas as posições que foram alteradas, mas duvido que tal tenha algo de útil, porque duvido que sejam muitas as posições que fiquem idênticas entre o princípio e o fim do ciclo. E, mesmo utilizando semelhante esquema, teria que indicar os índices das posições efectivamente modificadas

Em princípio, ainda vou ver se descubro neste enorme manancial de informação que se chama internet duas coisas: uma possível solução para o problema anterior e encontrar um problema que use o CGA de forma que seja digno de ser implementado neste projecto, ou melhor, esse problema é que devia tornar o meu trabalho digno de obter alguma resultado prático. A ver vamos...

Acabaram-se os caminhos tortuosos (pelo menos até agora...)

2005-09-05T23:52:00.000+01:00

Pois é, consegui finalmente aquilo que tanto queria: gerar todo o código em JAVA necessário para a implementação do serviço e do cliente usando o utilitário WSDL2Java. Consegui finalmente acertar com o WSDL correcto para poder fazer com que o serviço fizesse a coisa mais simples que eu pretendia: descarregar um vector população simples em conjunto com o parâmetro que indica o número de iterações (e, como a partir de agora, como passei a usar frequências absolutas em vez de relativas, o tamanho da população). Antes, a única que estava a conseguir efectuar era apenas entregar o vector população sob a forma de uma string. Mas era uma coisa "feita em cima do joelho", para desenrascar, e sem usar o WSDL. A questão é que em vez de usar um dos tipos primitivos como int, float, boolean ou string, o Web Service devia devolver um objecto. E aqui a porca torce o rabo, como raio é que consigo transmitir um objecto complexo através do SOAP ? Graças ao código gerado pelo WSDL2JAVA, fica tudo muito simples, e agora que finalmente consegui perceber para que raio é que server cada um dos ficheiros que o WSDL2JAVA gera, consegui escrever um cliente em menos de nada. Afinal os ficheiros de código gerados automaticamente e agora só percebi isso, facilitam realmente a vida, porque uma pessoa não precisa de estar a perder-se com pormenores mesquinhos e permite concentrar no essencial. No cliente invoco o nome da função "downloadPopulationVector" como se estivesse a acedê-la directamente (a configuração dos parâmetros é idêntica!). Deixo aqui o extracto do código SOAP do Web Service que envia um vector população de 5 posições, com frequências iniciais ajustadas a 10, para correr inicialmente 10 iterações e com uma população de 20 indivíduos:

<?xml version="1.0" encoding="UTF-8"?>
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<soapenv:Body>
<response xmlns="">
<pv>
<array>
<array>10</array>
<array>10</array>
<array>10</array>
<array>10</array>
<array>10</array>
</array>
</pv>
<n>10</n>
<popsize>20</popsize>
</response>
</soapenv:Body>
</soapenv:Envelope>

Depois do descanso...

2005-08-26T18:57:00.000+01:00

...pois é, após cerca de 13 dias de paragem por causa de ser o mês de Agosto, com o meu aniversário pelo meio e mais umas quantas ocorrências muito dificilmente iria ter tempo e disponibilidade mental para voltar a pegar nisto.
Da última vez que tinha pegado nisto estava com uns problemas de, ao, utilizar o One-Max, porque raio é que a população (ou melhor, o vector população) não convergia para frequências (estou a usar frequências absolutas) idênticas ao valor da população (estive a experimentar com cromossomas de comprimento 10 e população 40). Estou a fazer o cliente ir buscar um VP (vector-população) ao WS (Web Service), e correr apenas uma iteração do CGA (Compact Genetic Algorithm), de modo, que podia ir acompanhando passo a passo a intercomunicação entre o cliente e o servidor. Aqui um pequeno reparo: ao contrário de pôr o número máximo de iterações a ser executado em cada ciclo de obter/enviar a ser indicado pelo servidor, como era suposto a princípio, estou a fornecer esse limite directo no código do cliente. Por agora, o servidor de WS limita-se a fazer "eco" do VP que o cliente lhe envia, mandando, sem quaisquer alterações, de novo, o VP que tinha acabado de receber. Até agora, ainda não pus mais do que um cliente a correr ao mesmo tempo. Espero vir a fazê-lo em breve, com a ajuda do Multi-Threading de Java.
Mas,como estava dizendo, a dificuldade que vinha tento prendia-se com o facto de a população convergir precocemente antes do que era suposto, por exemplo, para um VP de 10 posições e população de tamanho 40, começa normalmente com:

20;20;20;20;20;20;20;20;20;20

mas depois em vez de dar no fim

40;40;40;40;40;40;40;40;40;40

estava a dar:

20;28;20;36;26;35;19;20;20;32

Achei estranho, e decidi investigar, descobri então, que eram gerados dois indivíduos do vector população, em cada iteração, estavam sempre a ser gerados os mesmos indivíduos a partir do vector população. Tal devia-se ao facto de o gerador de o números aleatórios estar sempre a ser inicializado com a mesma seed, o que fiz para resolver foi pôr uma seed diferente de cada vez que o algoritmo corre, seed essa dada pela hora do sistema, através da função System.currentTimeMillis(). Assim resolveu os problemas, pelo menos, por enquanto. Os meus passos seguintes deverão ser em princípio compreender melhor o Axis, para pôr o WS a devolver dois objectos em vez de apenas um, que é o necessário para se obter não só o VP mas o também o parâmetro m que indica o número de gerações que o cliente deve correr antes de devolver o VP ao servidor.

Já entrega...

2005-08-12T23:17:00.000+01:00

Enfim, depois de ter dado o passo principal e que consistia em pôr o WS a enviar o vector população "novinho em folha" para o cliente o poder processar para o problema em questão (eu experimentei o OneMax e a calcular o máximo do seno para um intervalo. Em ambos os casos, o cliente processava o vector população completamente até atingir a convergência, ao fim dos quais enviava o vector com a solução para o servidor invocando a função SendPopulationVector, devolvendo um inteiro que indica o estado de sucesso da operação (por enquanto limita-se a devolver 1).
Também, e como já tinha referido no post anterior, os problemas que estou a usar são simples e são resolvidos com poucas iterações. Por exemplo, para os testes que estive a usar, usei um vector de população que representa uma população de 40 indivíduos, cada um com um comprimento de 10 genes. Para o problema One-Max leva 100 gerações, enquanto para encontrar o máximo do seno leva 300. Nada que a minha máquina não resolva numa fracção de segundo.
Para problemas mais sérios terei mais tarde que um número máximo de iterações, o problema é que ainda não consegui descobrir como pôr o WS a devolver não apenas o vector população mas também esse valor, representado por m. É algo que terei que descobrir como se faz, tal como também mandar o vector população como deve ser com uma representação em array adequada de acordo com os standards do SOAP, e não a forma feita em cima do joelho, usando uma string. São ideias para desenvolver mais tarde, por enquanto interessa-me começar a desenvolver o trabalho no sentido de ficar o mais parecido com o que se pretende no enunciado do trabalho, mesmo que esteja implementado com coisas feitas em cima do joelho...

Finalmente alguma coisa a funceminar...

2005-08-11T18:39:00.000+01:00

Enfim, finalmente e após cerca de três semanas de férias e algumas dores de cabeça consegui desencalhar do ponto de não progressão em que estava também porque nos últimos tempos considerava que também estava de férias de forma que não estava a adiantar nenhum, e por outro lado também tenho ocupado os tempos com o meu vício quando não tenho mais nada para fazer - jogar Warcraft 3.
A minha dificuldade estava em fazer a coisa mais simples possível, que era pôr o Axis a devolver um vector população simples, através do uso de uma função também simples, que devolvia um array de floats e o mandava para o cliente, que a única coisa era simplesmente imprimir depois o conteúdo do vector que recebesse. Claro que estou a proceder ao desenvolvimento e teste na própria máquina (localhost), mas a minha maior dificuldade era a respeito de como transmitir o referido vector população através da rede. Como os Web Services utilizam SOAP para comunicar informação, e é baseado em XML, a dificuldade estava na forma como definir esse vector população de forma a ser transferido usando SOAP, ou seja, de que forma o vector população devia ser codificado em termos de SOAP de forma a ser transmitido efectivamente.
Aqui residia o maior problema, uma vez que o vector de população é um vector de números não inteiros e dessa forma teria de especificar um array quanto muito de double's. Acontece no entanto que o "array de float" não está nos tipos predefinidos que podem ser usados facilmente durante a descrição do serviço através do ficheiro WSDL. Eu julgava que o WSDL fosse a "base de tudo" para começar a definir os serviços a partir daí, mas afinal acabou por não ser assim.

O primeiro ficheiro WSDL que eu defini, que foi feito à "pata", através de exemplos no livro que ando a seguir, e de uns quantos mais, dava sempre erro quando eu tentava fazê-lo passar no WSDL2Java, que gera o código JAVA necessário para a implementação do Web Service de forma imediata tendo por partida apenas o WSDL e estava a usar esta ferramenta para não só gerar o código mas também verificar a síntaxe do WSDL. Acontece que estava sempre a falhar no momento em procedia a este último teste. Fartei-me de fazer aquilo manualmente e acabei por felizmente, após busca na net, um programa em JAVA chamado SOA Editor que permite rapidamente escrever o WSDL sem problemas. Daí a nada, tinha o WSDL que semprei quis ter, e finalmente o WSDL2Java gerou o tão ansiado código que já tinha perdido as esperanças alguma vez de o ver a conseguir obter.
Acontece depois que estive a ler o código gerado e não me agradou muito aquilo que vi, em vez de ser uma coisa simples por onde podia começar, era um código complexo, pronto para usar por pessoas já entendidas no assunto.
Não sabendo o que fazer com aquilo, desisti de usar o WSDL e andei nos últimos 10 dias a tentar encontrar uma solução simples que me permitisse enviar facilmente o vector população.
Sempre achei que o problema devesse estar no array de float's que tinha de definir como um "XML Schema" incorporado dentro do WSDL (no elemento ).
Ou não estava a definir muito bem, porque não percibia muieo disso, ou era o código gerado que não era suficiente esclarecedor. De modo que resolvi o problema da seguinte forma: para poder evitar estar a usar tipos não predefinidos, decidi representar o vector população sob a forma de uma string em que cada elemento do vector é separado do seguinte por ";". Desta forma simplificava a minha vida, e por outro lado, decidi trocar os números decimais por inteiros, uma vez que cada posição do vector população no caso dos números decimais representa a frequência relativa de uma alelo para aquele locus em toda a população, eu podia usar perfeitamente números inteiros, que representavam as frequências absolutas. E, ainda outra simplificação, omiti o parâmetro m, que indica o número de iterações a serem executadas entre cada "envio" do vector população ao servidor. Tudo para bem da simplicidade e da autodidáctica. E no fim, lá consegui, seguindo a par os exemplos patentes no manual do Axis e sem precisar de WSDL nenhum (aliás, o Axis gera-o automaticamente para o caso de ser necessário!) lá consegui finalmente ver o vector população enviado pelo servidor a ser recebido pelo cliente!
Depois pus o cliente a enviar para o servidor o vector população, também o recebia perfeitamente!
Agora o que me falta fazer é começar a pôr cada cliente a trabalhar em cada vector população que lhe é enviado. Começo no entanto a dar com um problema, todos os exemplos simples que tenho tentado, como contar o número de bits a 1 num cromossoma, encontra extremos num intervalo de uma função real de variável real, ou usar "traps", são problemas que se resolver num abrir e fechar de olhos e, de facto, não são nada úteis para testar a potência do trabalho. Tenho que encontrar um problema que seja realmente útil e bastante apelativo e que possa ser resolvido através da aplicação do meu projecto. A questão vai ser encontrá-lo. Mas, por enquanto, importa não pôr a carroça à frente dos bois e vou pensar em pôr tudo o que for Web Services a funcionar! Desejem-me sorte !

Mas que raio é WSDL ?

2005-07-29T13:25:00.000+01:00

WSDL, é de acordo com o tutorial patente nos W3Schools, Web Services Description Language, e serve para descrever em detalhe e pormenor todas as características de um Web Services, o protocolo de suporte para transmissão da informação (HTTP,SMTP,etc), quais os parâmetros necessários para invocar o Web Service (WS), assim como os parâmetros de retorno esperados. Ao fim e ao cabo, o WS pode ser visto como se fosse uma função de Linguagem de Programação, sendo que nós (o cliente) temos que pedir com o nome do WS e os parâmetros necessários (ou sem eles, como acontece num caso concreto em que estou a trabalhar), sendo-nos facultada uma resposta pedida.
Por exemplo, podemos ter um WS que devolva a data actual, e vamos imaginar que o WS se chama GetDate. Como é natural, não são necessários quaisquer parâmetros neste caso, e o nosso programa-Cliente cria uma mensagem SOAP para ser enviada por HTTP para o Fornecedor do WS (que vou designar por WSP, do inglês Web Service Provider). Este último, deve então, enviar, também através de SOAP, a informação requerida. Ora, então, o WSDL é o ficheiro que descreve em XML tudo que acabei de descrever.
Aqui fica um WSDL simples para o exemplo que estive a referir, supondo que o URL do WSP é http://www.getdate.com/getDate/ (não usem este endereço porque ele não existe é claro!)


<?xml version="1.0" encoding="UTF-8"?>
<definitions
    name="WebServCGA"
    targetNamespace="http://www.getdate.com/getdate"
    xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
    xmlns:tns="http://www.getdate.com/getdate/getdate.wsdl"
    xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema">

<MESSAGE name = "getDateRequest">
</MESSAGE>
<MESSAGE name = "getDateResponse">
     <PART name = "date" type = "xsd:dateTime" >
</MESSAGE>
< PORTTYPE name="getDatePortType" >
<OPERATION name="getDateOperation">
    <INPUT message="getDateRequest" />
    <OUTPUT message="getDateResponse" />
</OPERATION>
</PORTTYPE>

  <binding name="getdateBinding" type="tns:getdatePortType">
        <soap:binding style="document" 

transport="http://schemas.xmlsoap.org/soap/http"/>
        <operation name="getDateOperation">
            <soap:operation
                soapAction="http://www.getdate.com/getdate/"/>
            <input>
                <soap:body parts="" use="literal"/>
            </input>
            <output>
                <soap:body parts="" use="literal"/>
            </output>
        </operation>
    </binding>

    <service name="getdate">
        <port binding="tns:getdateBinding" name="getdatePort">
            <soap:address location="http://www.getdate.com/getdate"/>
        </port>
    </service>

</definitions>

De acordo com o que ficou antes expresso, podemos olha para os elementos MESSAGE
como especificando cada uma das "funções" de que o WS é composto, ou melhor: a função
de que podíamos pensar como analogia de acordo com o exemplo acima, é partida em
duas: uma para enviar (GetDateRequest) e outra para receber (GetDateResponse).

Estas duas partes são "incorporadas" numa OPERATION, que especifica qual a MESSAGE de INPUT e qual a de OUTPUT. O elemento PORTTYPE permite incorporar várias OPERATIONs (se houver mais do que uma). Os PORTTYPE caracterizam o WS em abstracto, coisa que o BINDING se encarrega de fazer em concreto, ao especificar através do protocolo SOAP o meio através do qual o WS é transmitido. Finalmente, o SERVICE permite especificar qual o URL através do qual o WSP pode ser acedido, isto partindo do princípio que estamos a transmitir SOAP sobre HTTP, que é, aliás, o mais frequente.

Mas o que raio é SOAP (I) ?

2005-06-15T17:37:00.000+01:00

Para quem anda a iniciar-se no fantástico mundo dos Web Services, começa a levar com uma "palete" de siglas e acrónimos, dos quais os que sobressaem mais são dois: WSDL e SOAP. Sobre WSDL vou-me debruçar num artigo seguinte, por enquanto vou ocupar-me do SOAP. Ao contrário do que se possa pensar, SOAP não tem nada a ver com "sabão", mas provavelmente foi escolhido com o propósito de ficar com um signficado sugestivo. SOAP quer dizer Simple Object Access Protocol e é um protocolo baseado em XML, tal como todos os protocolos que se usam nos Web Services. Este protocolo foi criado para definir as mensagens que os Web Services usam . Apesar de usar XML, e por via disso vir num formato de texto que é legível por seres humanos, tal permite a sua flexibilidade e extensibilidade a toda uma variedade de necessidades diferentes. A mensagem SOAP é constituída por duias partes: um "envelope" que define toda a mensagem e que se separa em duas partes: Cabeçalho (Headers) e Corpo (Body).

Um pequeno exemplo do que pode ser o aspecto duma mensagem SOAP aparece de seguida:

<?xml version="1.0" encoding="UTF-8"?>
<SOAP-ENV:Envelope

SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

<SOAP-ENV:Body>
<doCheck>
<arg0 xsi:type="xsd:string">947-TI</arg0>
<arg1 xsi:type="xsd:int">1</arg1>
</doCheck>
</SOAP-ENV:Body>

</SOAP-ENV:Envelope>

O cabeçalho contém normalmente informação sobre os XML Schemas
que definem os namespaces em utilização na mensagem e o corpo
contém a informação propriamente dita.

Para que servem os web services (parte 2)

2005-04-24T00:40:00.000+01:00

Um bom exemplo para ajudar a perceber o que são e para que servem os Web Services era por exemplo o caso que se quiséssemos directamente o serviço de pesquisa de sites do Google no nosso site, tipo mostrar os resultados do Google na nossa página directamente usando algum assunto que estivesse relacionado com o conteúdo da página. Assim, por exemplo, poderíamos estar interessados em fazer uma pesquisa intensiva no Google para saber o nosso pagerank, ou para saber qual a ordem em que o nosso site, aparecia no nosso site. Poderíamos usar scripts em PHP que fizessem isso, de forma automática, a executar de x em x tempo através do uso do Crontab e podia-se também mandar os resultados para uma base de dados, para mais tarde poder fazer comparação de dados ao longo do tempo, como por exemplo saber como estaria a evoluir o nosso site ao longo do tempo na ordem de resultados do Google. Mas de um momento para o outro os webmasters do Google decidiam mudar o design (que na realidade não tem mudado muito nos últimos anos!!!) da página de resultados. Então, chapéu, os nossos scripts que estavam a fiar-se no anterior design do Google deixariam pura e simplesmente de funcionar, e lá teríamos de andar sempre atrás da vontade dos webmasters do Google, quando eles quisessem mudar a estrutura lá nós teríamos que fazer isso. Tudo isto dá para ter uma ideia até que ponto o HTML é imperfeito, uma vez que se trata de uma linguagem orientado para a formatação de páginas para leitores humanos e não é ideal como suporte para a transmissão pura e simples de informação. É aqui que entra em jogo o XML como veículo ideal para a transmissão de informação sem quaisquer preocupações no que toca à apresentação.
Na realidade, se nós quisermos usar o Google para apresentar os seus resultados na nossa página tal já existe: são as Web APIs do Google, se bem que ainda em fase experimental, estando limitada se não me engano ao máximo de 100 acessos por dia, com isso já podemos mostrar os resultados do Google na nossa página sem quaisquer encargos!

Para que servem Web Services (parte 1)

2005-04-23T01:09:00.000+01:00

Após a leitura completa do primeiro capítulo do livro que referi no post anterior, deu para ter uma ideia bem... para falar a sério, no meio de tamanho emaranhado teórico, blablah e esquemas deu para perceber algumas coisas importantes, que me afloram neste momento à mente, acima de outras:

os web services são úteis para interligar toda uma panóplia de serviços que, de outra maneira não seria possível. Deste modo, é possível usar Web Services para as mais variadas utilizações, que podem perfeitamente interagir através do uso de uma interface que é facilmente descrita usando o WSDL, que é comunicado aos clientes.
para os potenciais clientes dos Web Services, existe um serviço tipo "páginas amarelas" ou directório, que permite a interligação entre todo o manancial de Web Services existentes na Internet. Foi desenvolvido um sistema chamado UDDI, especificamente para esse efeito
Os Web Services podem ser clientes de outros Web Services, e graças ao Web Services Registries, é possível, vamos imaginar, que quando um Web Service deixe de estar disponível, seja imediatamente substituído por outro ofereça uma função semelhante
Oferecendo uma interface comum, que é descrita em XML, uma vez que é um formato de texto facilmente legível por humanos e de fácil edição, é sem dúvida o principal responsável por essa universalidade dos Web Services.
Os Web Services podem utilizar não apenas o protocolo HTTP para a sua distribuição, mas também muito bem usar outros protocolos como o FTP e o SMTP.

A ver bem, o JAVA é mesmo a linguagem de eleição para usar Web Services, porque graças à sua quase universalidade a nível de suporte, permite que praticamente todas as plataformas como Sistemas operativos ou arquitecturas possam interagir entre si.

O projecto não acabou ... :)

2005-04-09T14:13:00.000+01:00

Estou a mandar este post cerca de um mês após o último post. Só para dizer que o meu projecto não acabou, tem andado "emperrado" por culpa de ter ainda duas disciplinas para além do projecto, nomeadamente Inteligência Artificial (que ficou pendurada do ano passado) e Programação Funcional e Lógica. Também pudera, devido à grande complexidade dos Web Services em Java e mais propriamente do engine Axis, atraves do qual são "distribuídos" os Web Services. Entretanto, pelo meio, arranjei, através do meu orientador, este livro, dos autores do Axis, e que, por aquilo que já vi, espero que me venha auxiliar bastante na elaboração do projecto. Até agora, por aquilo que já li, não fiquei nada aborrecido na escolha do livro, o problema está sobretudo relacionado com a quantidade de conceitos que eu terei de adquirir para me poder lançar no projecto, é que isto dos Web Services joga com tanta coisa, é com cada sigla maluca: XML, XML-RPC, SOAP, WSDL, UDDI, JWS, JSP . Vamos a ver como me desenrasco disto tudo! Desejem-me sorte! :)

Uma menção honrosa ;)

2005-03-01T01:34:00.000Z

Qual não foi o meu espanto hoje quando recebi uma mensagem do meu orientador dizendo que o meu blog, tinha sido encontrado pelo grande David Goldberg, talvez um dos nomes que vem logo à cabeça de quando se fala de Algoritmos Genéticos, a par de David Holland, encontrou o meu blog, enquanto andava na net, e colocou esta referência no blog do IlliGAL (Illinois Genetic Algorithms Laboratory , em português, Laboratório de Algoritmos Genéticos da Universidade de Illinois). Só tive pena é de realmente o meu blog não ter nada em inglês, mas quando eu tive a ideia de conceber este blog, fi-lo apenas com a intenção que ele servisse como uma forma dos meus colegas e outros potenciais interessados podessem ir acompanhando o decorrer do meu trabalho. Não sei, mas a possibilidade de fazer em inglês não deixa de ser uma hipótese, mas não tenho grande vocação para me expressar na língua de Shakespeare (percebo perfeitamente inglês, agora para mim expressá-lo a conversa é completamente diferente!), e isso por outro lado, ia de certo modo contra a intenção original com que criei este blog. Mas realmente, talvez comece a considerar a hipótese de começar a fazer alguns post's em inglês, isto se o meu blog começar a despertar interesse não só entre os meus colegas, como em geral toda a Internet. Vamos ver o que o tempo dirá :).
Aproveito para referir que o IlliGAL, que é o laboratório onde o prof. Lobo andou a trabalhar nos Estados Unidos (assim como o meu colega Cláudio Lima, que está a tirar o doutoramento esta área), também possui o seu próprio blog, apesar de ser um tanto recente, mas é bastante intessante, porque ele tenta dá um apanhado de tudo o que vai encontrando na net e que tem a ver com a aplicação dos algoritmos genéticas. Deixe também um link para a home page do IlliGAL. Eu só gostava de saber era onde eles se lembraram de ir criar esta sigla :)

Ponto de não progressão!

2005-02-27T22:05:00.000Z

Pois é, desde que iniciei em termos efectivos o projecto desde já quase há um mês (5 de Fevereiro) atingi um ponto que se pode considerar como de não progressão, e isto porque, apesar do código do CGA já estar num nível que eu poderei considerar de certo modo aceitável -com uma nova classe MyRandom para gerar numeros aleatórios inspirado num código em C++ que me foi cedido pelo meu orientador e que se baseia em grande parte neste artigo da ACM - Random number generators: good ones are hard to find, da autoria de S. K. Park e K. W. Miller. O problema agora trata-se de experimentar pela primeira vez os Web Services, e o que eu quero fazer pela primeira é uma coisa mínima, fazer com que um cliente (worker, melhor dizendo) descarregue um vector-população a partir do manager, mas para conseguir fazer isso vou ter que mexer em classes de JAVA como a JAX-RPC, que, como de acordo com o que está no link anterior, se trata de uma biblioteca de JAVA que permite evitar ao programador o acesso directo ao protocolo SOAP. Como ainda não estudei a fundo a API do XML-RPC, não posso estar por aqui a dar detalhes. Tenho andado a tentar seguir este tutorial, que se baseia no TomCat, ao contrário do último, que usa ao invés um webserver qualquer da Sun, que já tive oportunidade de experimentar e que é muito pesado, por isso optei por não o seguir, não se fiz mal, mas as diferenças não são grandes. O problema é que os passos descritos são para ser usados para o caso em que se usa directamente o TomCat directamente para implementar os Web Services, e não por intermédio do Axis, como pretendia inicialmente. O problema é que ainda não encontrei um tutorial de Axis verdadeiramente condigno que me explicasse as coisas são assim, assim e assado, e tens que fazer estes passos para chegar lá. Só encontrei um que me explicava as coisas, mas tratava-se de usar ficheiros JWS, que são no entanto Web Services demasiado básicos para o meu gosto e que no fundo parecem mais receitas rápidas para demonstrar que o Axis funciona, do que bons exemplos que permitam Web Services mais complexos e aceitáveis. Por isso, que pelos vistos, vou ter que fazer um meio-termo entre o tutorial da Sun e o manual do Axis . O Axis permite simplificar a vida, permitindo gerar o código JAVA directamente a partir do WSDL, graças à ferramenta WSDL2Java, existindo também a recíproca, Java2WSDL . Para além de tudo isto, ainda por cima, chega finalmente a 3ª semana do 2º semestre, em que acho que o "2º semestre" vai começar a doer, em que as disciplinas de Inteligência Artificial e Progtamação Funcional e Lógica me vão dar água pela barba que chegue!!! De modo que acho, que se isto começar a dar problemas, o projecto vai ter que ficar em banho maria!!!

Mas que raio de WSDL...

2005-02-21T17:25:00.000Z

Agora que já consegui realizar uma primeira implementação do CGA em JAVA, falta interligar com a outra parte do projecto e que tenho vindo a aprender por custo próprio aos poucos: fazer o algoritmo genético circular pela rede, ou seja, pôr clientes a trabalhar num vector população e criar um servidor que gira (de gerir) o trabalho de todos os clientes, distribuindo por todos os clientes o vector população que necessitam para por o CGA a trabalhar. Basicamente, trata-se de uma arquitectura "worker-manager" que é explicada neste artigo. Tenho, portanto, de pôr um manager (ou servidor) e workers (ou clientes) a comunicarem entre si através de Web Services. E para definir Web Services é necessario criar um ficheiro XML que descreva os Web Services atraves de um formato conhecido por WSDL. Atraves deste formato sao descritas coisas como o nome da API (função), como os seus parâmetros, o seu tipo assim como o tipo de retorno da função que o cliente necessita de invocar do motor de Web Services (eu chamo-lhe motor porque é um módulo que roda num servidor Web, ou seja, é um componente do servidor e não um servidor por si próprio, que neste caso concreto é o Apache Axis). Deste modo, é definida uma interface do Web Service (WS), que pode ser explorada por toda uma diversidade de clientes, escritos nas mais variadas linguagens. Pois é assim mesmo que deve ser: uma vez que na Internet coexistem a mais diversas plataformas e linguagens, um formato universal que permita descrever a interface do WS de modo que permita que qualquer cliente o possa utilizar. De modo que neste momento as dúvidas é que se põem estão relacionadas sobre quais devem ser as APIs a utilizar, eu pensei nas seguintes, não sei se serão as melhores, mas em minha opinião acho que não desagradam:

DownloadPopulationVector - o worker pede ao manager um vector população com o qual possa começar a trabalhar. Este passo é feito no princípio por um novo worker disposto a iniciar um novo trabalho ou então na ocasião em que estando completo o trabalho depois de cumpridas m iterações do algoritmo - que é por outro lado, um parâmetro da resposta enviada pelo manager ao worker quando é descarregado o vector população para o worker - de modo que o worker possa saber quando a fase presente de trabalho terminou e pode enviar o resultado obtido para o manager.

SendPopulationVector - o worker completou finalmente o seu trabalho e está disposto a enviar o vector população apenas com as diferenças entre o último vector população que recebeu do manager e o estado em que ficou o VP (vector população) depois de cumpridas as tais m iterações estabelecidas pelo manager. A esta solicitação o manager deve responder - depois de verificar se o VP já atingiu alguem critério que permita terminar o algoritmo - com uma resposta que informe a conclusão do trabalho ou então. No caso da resposta ser negativa, ou seja que o VP ainda não convergiu, então o cliente tem o dever de invocar a API anterior para que possa descarregar um novo VP e prosseguir o seu trabalho.

Até agora, é este o "estado do arte", que, no entanto, ainda nem comecei a implementar!!! É apenas, por enquanto, e ainda, uma declaração de intenções.

Numeros aleatorios muito pouco aleatorios

2005-02-18T17:42:00.000Z

Nos algoritmos em que ando a trabalhar, é indispensável o uso de números aleatórios durante para gerar a população inicial, ou no caso concreto do CGA, para gerar os cromossomas dos indivíduos que se confrontam. A utilização de um gerador fidedigno é essencial para o bom funcionamento. E o que deve ser um gerador fidedigno ? Por poucas palavras, é um gerador em que, dado um determinado intervalo dentro do qual se pretenda obter os valores aleatórios, a probabilidade de sair um número é exactamente idêntica à de outro qualquer. Para melhor compreender estes assuntos, suponhamos um intervalo entre 0 e 1, dividido em 100 partes, assim em princípio, se pedirmos ao gerador para criar um número aleatório 100 vezes, a probabilidade de calhar um número em cada um desses intervalos é de 1%. Se forem 1000 vezes, a frequência absoluta é de 10 e 10000 de 100. Quanto maior for a amostragem, mais as probabilidades de cada intervalo se equilibram entre si.
Deste modo, decidi correr um programa para decidir se o gerador era o mais fiável possível baseado no exemplo que descrevi acima, isto apesar de acordo, com a teoria, geradores aleatórios perfeitos são coisas que não existem. Submeti então ao programa o gerador de números aleatórios baseados no código que o meu orientador me forneceu, assim como o gerador que vem com a biblioteca da Java.
Deixo aqui uma imagem que ilustra o resultado do programa para algoritmo extraído do SGA e baseado no livro do Goldberg:

Acho que se pode concluir que o gerador não é assim tão mau !!!

Qual o melhor IDE ?

2005-02-13T23:55:00.000Z

Como nestes próximos tempos vou estar bastante ocupado no projecto programando em JAVA, ando à procura de um IDE (Integrated Development Environment) - ou Ambiente de Desenvolvimento Integrado, na língua de Camões - que me permita potenciar a produtividade, e para mim, os aspectos essenciais que me dão mais jeito são:

Em primeiro lugar, que me dê a capacidade de aceder à documentação de JAVA da forma mais rápida e eficiente possível sem ter que estar a perder tempo a perder tempo a fazer cliques para encontrar o documento referentre à classe da biblioteca de Java de que preciso.
Que seja initituitivo, isto é, que eu não ande perdido uma eternidade à procura como se faz uma "merdazinha" que se faz num instante num outro IDE a que eu já esteja acostumado
Permita detectar erros que normalmente não se detectam entquanto se está a escrever o código, isto que só são detectados em tempo de execução, ou seja.
Capacidade de auto-completar expressões bastante vulgares como por exemplo escrever automaticamente as duas expressões mais compridas e vulgares que existem em Java e que são:

public static void main(String[] args)
{
//...
}

System.out.println("blablabla");

Eu sou uma pessoa que se chateia com facilidade com repetições, nem as posso ver à frente, e um IDE que me permita evitar chatices é um passo decisivo para entrar nos meus gostos.

Tenho andado a experimentar três IDEs: o JCreator, o Netbeans e o Eclipse. De todos o que eu uso há mais tempo é o JCreator, pois é escrito em C++, tendo um tempo de arranque bem mais curto que os outros dois, é intuitivo e facilita imenso a navegação nos javadocs, mas não tem capacidade de detectar erros que normalmente só se encontram em tempo de execução, coisa que os outros dois IDEs - o Netbeans e o Eclipse - sabem fazer e bem. Por outro lado, estes dois últimos têm uma capacidade de integração com CVS bastante avançada (o JCreator só incluiu esta propriedade na última versão - a 3.5) e o NetBeans traz já integrado um editor ao estilo de Visual Basic para quem gosta de desenhar caixas, janelas e botões para o Swing (a biblioteca para criação de GUIs do Java), para não falar de trazer um servidor de JSP - o Tomcat. O Eclipse é que não traz de raíz um editor gráfico - mas essa falha pode-se corrigir, puxando o respectivo plug-in. Mas, falando a sério, o Eclipse não é editor exclusivo para JAVA, a sua extensibilidade é muito maior. Aliás o Eclipse, é de acordo com a IBM, que o criou e depois o libertou para o movimento open-source, um "meta-IDE", ou melhor, uma espécie de ambiente de criação de IDEs, uma vez que pode ser facilmente integrado com qualquer linguagem, havendo já plug-ins para C++, Perl, Python, Bash e PHP. É verdadeiramente um IDE "multi-plataforma". Apesar da grande sofisticação destes dois últimos IDE's, não estando em nada abaixo de IDEs mais profissionais e comerciais como o Visual Studio .NET da Microsoft, o preço a pagar por esse facto e por serem escritos em JAVA é o tempo de arranque e o gasto de recursos: tanto o NetBeans como o Eclipse são dois devoradores de memória e levam mais de um minuto a arrancar desde o momento que clico no icone até ser possível escrever alguma coisa. Quanto ao gasto de RAM, eles começam de mansinho nos 50 MB, mas dali a dez minutos já andam nos 100 MB. Não, recomendo, por isso, a utilização destes IDEs a quem tiver um computador mais lento que 1 GHz e menos de 256 MB de RAM (o meu tem 1800 GHz e 384 MB).
Apesar de tudo, os IDEs baseados em JAVA tem a vantagem que é o grande slogan da linguagem criada pela Sun: Compile one time, run everywhere, pode-se trabalhar em qualquer SO.

JGAP!

2005-02-12T23:44:00.000Z

Quando andei na net à procura de possíveis problemas que possam ser resolvidos por meio de algoritmos genéticos, deparei-me com este projecto hospedado no Sourceforge que dá pelo nome de JGAP (ou JAVA Genetic Algorithms Package), uma biblioteca em JAVA que dá para ser utilizado livremente em qualquer outro projecto, desde que cumpra os requisitos da licença estipulada no Web Site. Tive a experimentar como funcionava, experimentando com a mais simples das funções de Algortimos Genéticos, o One-Max (que devolve o número de uns existentes num cromossoma) e funcionava. Engraçado é que aquilo, pelo menos porque tive oportunidade de ver a documentação ainda um tanto superficialmente não tem um critério de convergência para paragem do algoritmo quando for atingida a "melhor solução". Mas deve andar para lá. Aqui fica uma lista de trabalhos científicos que citam o JGAP. Deixo também um link para uma página que apresenta a equipa por trás do projecto.

CVS = Concurrent Versions System

2005-02-12T00:30:00.000Z

Pois é ! Tenho andado a aproveitar estas férias que estão quase terminadas da melhor maneira ! Ando a aplicar-me e decidi finalmente embalar-me e tentar perceber que raio é isso que provavelmente alguns de vocês já terão tropeçado e que dá pelo nome de CVS. Provavelmente alguns de vocês já depararam nisso enquanto estiveram a explorar algum IDE (Ambiente de Desenvolvmento) numa opção chamada "CVS". Pois bem: o CVS serve para que em empresas com equipas de vários programadores possam desenvolver em grupo diferentes porções do projecto comum em que estão envolvidos. Deste modo enquanto um colega edita um ficheiro A, outro programador pode estar a trabalhar no mesmo ficheiro e é usado um repositório onde são guardadas todas as versões passadas e conhecidas de todos os ficheiros que alguma vez fizeram parte desse projecto. É possível também recuperar versões antigas de determinado ficheiro, se for caso disso. A mim isto interessa-me para o projecto porque assim posso estar a trabalhar nisso em qualquer lugar. Através de um repositório guardado no computador do laboratório 2.56 que me foi adjudicado, posso importar os ficheiros e trabalhar em qualquer outro computador da universidade, basta apenas ter um cliente de CVS instalado na máquina para onde desejo ir trabalhar. Por outro lado, é bom, porque dá um aspecto profissional a toda a cena. O CVS é praticamente universal, sendo praticamente o software "standard" usado em todo o mundo por grupos de programação dedicadas a produção de software "a sério". O Sourceforge.net suporta CVS para todos os membros de um projecto, deixo aqui o link para um dos projectos (o TightVNC) de maior saída e que são um bom exemplo daquilo que o Open Source é capaz. Deixo também aqui um link para o repositório do PHP

Java server pages, SAAJ, JAX-RPC, tudo uma grande confusão...

2005-02-10T23:30:00.000Z

Pois é, nestes últimos tenho-me aventurado pelo grande mundo das Java Server Pages (JSP). Para alguém, como eu, que vinha do PHP e, pensava que todos os geradores dinâmicos de páginas fossem todos do género da simplicidade do PHP para configurar e começar a programar vaiam tirando o cavalinho da chuva. Para correr JSP é necessário um web server próprio, para além, de é claro, uma máquina virtual java com compilador instalada na mesma máquina onde esteja a correr o servidor de JSP, que, no meu caso, é o Apache Tomcat , e, uma vez por aquilo que li é, de entre todos os servidores de JSP, o mais chato de configurar porque é tudo feito via ficheiros do configuração, como o seu irmão mais velho, o servidor Web Apache propriamente dito. Acontece que o Tomcat é standalone, quer dizer, não depende da existência de outro servidor HTTP na mesma máquina, e corre numa porta própria: por defeito a 8080. É no entanto, possível interligar os dois através de dois módulos do Apache: um é o mod_proxy, outro é o mod_jk. Um ou outro, como tive oportunidade de testar funcionam bem: o melhor é o segundo, porque foi especialmente desenvolvido para esse efeito.
O problema é com Apache e Tomcat na mesma máquina o consumo na mesma máquina (eu testei em Windows) vai para cima dos 50 MB e o Tomcat como é escrito em JAVA, demora meio-minuto a arrancar completamente, mas depois, já de pé, não fica em nada atrás do Apache. O problema é que para depois tar a configurar aquilo tudo como deve de ser, não é nada simples para quem, como eu, está habituado ao "velho" Apache. As JSP é um mundo muito próprio que fala a sua própria língua.
Assim, por exemplo, em JSP, e ao contrário do PHP em que só existe dois tipos de tags : <? ?> e <?= ?> no PHP existem até quatro, parecidas com ASP: <% %>, <%= %>, <%! %>, e <%@ %>. Enquanto as duas primeiras têm practicamente a mesma finalidade das que lhe são idênticas em PHP, as duas últimas são específicas, a terceira é para declarar código Java de forma livre e a última é para declarar directiva, do estilo de import's, ao que parece, ainda não naveguei nisto a fundo para perceber isto ? Mas para que raio eu preciso de saber isto tudo ? Acontece que estou pensando em escrever Web Services usando JAVA, daí que precise de usar JSP. O Axis, motor que eu pretendo usar sobre o Tomcat, é escrito em JSP, e posso vir a precisar de saber JSP para saber como escrever os Web Services. Ainda não sei como isso se faz, mas espero vir a saber.

Entretanto, a implementação do CGA em JAVA vai "nos eixos": tem passado em quase todos os testes. Nem era de surpreender, dada a sua simplicidade, depois de usar o One-Max, a mais simples das funções em Algoritmos Genéticos, tentei experimentar com a Trap Function, mas acho que não sei muito bem como aquilo se define. Para determinar o máximo de funções reais de variável real é que tem funcionado perfeitamente !!! Agora espero conseguir resolver outros problemas com o meu CGA em Java. Net aí vou eu....

Primeira implementação concluída

2005-02-08T02:36:00.000Z

Consegui terminar a primeira implementação do CGA em Java. Comecei por fazer tudo numa única classe e no método main, seguindo a passo a descrição existente no artigo original do meu orientador. Já com o algoritmo e tudo a funcionar comecei por experimentar pela função mais básica quando se trata deste campo dos algoritmos genéticos - a one-max, que consiste em simplesmente contar o número de uns presentes no cromossoma. Até aqui tudo bem, mas quando fui usar com a função trap, é que as coisas já não correram tão bem de feição. Provavelmente eu não me recordo é perfeitamente de como se constrói a função trap.
Após ter tudo a funcionar comecei a modulizar e a organizar o código: o algoritmo genético compacto passou a classe abstracta, de modo que para ser implementado é necessário fazer uma subclasse descendente que implemente a função fitness. Deste modo é possível fazer a reeutilização de código de acordo com o tipo de problema. E estou já em querer imaginar um tipo de problema concreto que eu possa utilizar para utilizar o algoritmo. É bom ver o meu trabalho começar já a dar os seus frutos.
A outra parte vai ser como aprender a desenvolver os Web Services. Esta parte vou ter eu que aprender inteiramente sozinho, mas a minha intenção é usar o motor Apache Axis, baseado em JAVA, que para funcionar precisa do suporte do Tomcat, que é um servidor Web baseado em JAVA desenvolvido pela Apache Foundation que serve para albergar JSP (Java Server Pages). Eu neste momento ignoro quase a 95% o que eu vou ter que fazer para por os Web Services a funcionar, quanto mais interligar o algoritmo genético compacto com os Web Services. Até agora só vi a parte emersa do iceberg, agoro vou querer ver os restantes 95% que estão debaixo da superfície!

Primeiro post

2005-02-06T11:26:00.000Z

Este é o primeiro post neste blog, que temporariamente irá receber o nome de WebServCGA, contracção de Web Services for Compact Genetic Algorithm. Enquanto não encontrar nada de melhor, vou usar precisamente este nome. Diaria ou semanalmente, espero eu, vou dando aqui as impressões da forma como o trabalho vai decorrendo. Espero que, quando chegar ao fim deste projecto, eu possa, ao rever todo este blog do princípio, os sacrifícios que fiz até ter conseguido alcançar um resultado que espero que seja o mais frutuoso possível.