Oracle XE

A Oracle lançou a Oracle Database 10g Express Edition. Trata-se de uma versão gratuita da conhecida base de dados Oracle 10g.
Esta nova versão tem como particularidade o facto de poder ser distribuída de forma embebida nas nossas aplicações, mesmo para fins comerciais. No entanto nem tudo é ouro, pois esta versão sofre de algumas limitações. Por exemplo, a capacidade máxima dos dados que se podem armazenar tem como limite os 4GBs. Adicionalmente, mesmo que esta aplicação seja executada por um sistema com vários processadores, apenas um deles será utilizado, o que na era do “Hyper-threading” se pode tornar numa grande desvantagem.

Seja como for, aqui está uma boa noticia que abre um excelente precedente.

Abraços,
  Gama Franco

Em integrar é que está o ganho.

Quando se usam metodologias ágeis, é comum compilar o código regularmente e correr os teste unitários. Quando se têm equipas grandes, torna-se imperativo que esta tarefa seja efectuada de forma automática e controlada.
A esta etapa chama-se integração. É suposto que o código desenvolvido por um utilizador seja integrado com o do resto da equipa assim que a tarefa é terminada. O servidor de ‘builds’ vai confirmar se a integração foi ou não feita com sucesso através dos testes.

Este artigo explica de forma mais detalhada o procedimento. Espero que vos seja útil.

Abraços,
  Gama Franco

GanttProject

Descobri no outro dia uma excelente ferramenta para gestão de projectos, o GanttProject.

Trata-se de uma aplicação desenvolvida em Java, que permite a elaboração de gráficos de Gantt, Pert, etc. Enfim, as coisas básicas e essenciais para um plano de projecto. Além destas coisas todas ainda permite que sejam importados projectos de várias ferramentas, incluindo o MS Project.

Tudo isto numa ferramenta GPL e multi-plataforma.

Abraços,
  Gama Franco

Lamechices

O post lamechas mais comum da blogosphera.

Queria desejar um bom natal aos leitores, com muitas prendas e muito vinho.

Abraços,
  Gama Franco

Installer para Java

Já que estamos com as mãos no Java, cá vai mais uma pérola.

O AdvanceInstaller é uma ferramenta que permite criar um pacote de instalação de aplicações Java, à moda do Windows (MSI). Tem uma versão gratuita, que a meu ver é bastante completa. Tudo através de uma interface gráfica, fácil de utilizar.

Abraços,
  Gama Franco

COTS de gráficos para SWING

Andava eu a desesperar por não encontrar COTS de jeito para SWING e dou de caras com o JFreeChart. Tem bom aspecto, dá vontade de comer (

Abraços,
  Gama Franco

Há merdas que me deixam indignado.

O presidente da câmara municipal de Lisboa vai hoje propor à assembleia municipal a introdução de um imposto de 0,25%, nas facturas de telecomunicações dos seus munícipes. Este imposto servirá para financiar obras na rede de telecomunicações do concelho.

Para quem pensava que o negócio das telecomunicações estava em alta, desengane-se. Parece que afinal dá prejuízo. De tal forma que serão os cidadãos a financiar infra-estruturas exploradas pelas empresas do sector.

Um abraço,
  Gama Franco

Evoluir para pior

Nos dias que correm assistimos à migração da lógica para ficheiros de XML. São cada vez mais as tecnologias que acabam por convergir para esta nova filosofia, incluindo a ‘Avalon’, a nova camada de apresentação da Microsoft. Justiça seja feita, pode-se enumerar uma excepção a esta regra; EJB 3.0. Agora que o Java descobriu as anotações, o mundo dos EJBs acabou por suprimir a necessidade de se criarem três (sim três) ficheiros XML por cada ‘Bean’.
Como já devem ter percebido, não estou muito satisfeito com esta nova filosofia. E penso que existem argumentos fortes para justificar o meu ponto de vista. O facto de se andarem a elaborar ‘Domain Specific Languages’ (DSLs) em XML é o suficiente para deixar qualquer profissional de TIs no mais profundo desespero, senão vejamos.

Ando a investigar tecnologias para desenvolver ‘Rich Client Applications’, ou seja, interfaces gráficas que correm em programas instalados no computador do utilizador. E qual não é o meu espanto quando verifico que existem inúmeros projectos emergentes que possibilitam o desenvolvimento de interfaces através de ficheiros XML. O programador acaba por desenvolver uma parte considerável do código neste tipo de ficheiros, que mais tarde são interpretados por um motor gráfico. O curioso é que a maior parte das vezes o XML não chega, e acabamos por ter a lógica do programa espalhada por duas DSLs diferentes (i.e. Java e XML).

Mesmo que as tecnologias permitissem o desenvolvimento integral da aplicação numa DSL desenvolvida sobre XML, esta filosofia acabaria por empurrar o software para linguagens que são interpretadas em vez de compiladas. E este factor é mais que suficiente para causar problemas e deixar os intervenientes à procura de erros no código pela noite dentro. Basta ter em conta que:

• Muitas vezes estas DSLs não têm XML Schemas, deixando o programador à mercê da documentação e dos exemplos, quando existem


• O Schema, quando existe, não muito é fácil de interpretar por humanos


• Uma linguagem interpretada não detecta erros em tempo de compilação, simplesmente porque esta fase não existe. Alguns IDEs conseguirem encontrar incoerências no XML através do Schema, mas não é a mesma coisa


• Ainda não existem técnicas de ‘refactoring’ decentes para facilitar o desenvolvimento e a manutenção do projecto


• O XML foi desenvolvido com foco nos dados e não no código

Mas nem tudo são más noticias, pelo menos para as empresas que fornecem as tecnologias. Quando as coisas já se encontram estabilizadas e bem definidas no paradigma orientado aos Objectos, eis que surge uma nova filosofia e há sempre quem venha a ganhar balúrdios com migrações e formações adicionais. No papel que me toca, não vejo qualquer vantagem nesta “nova” filosofia, e antevejo muitas noites em branco no dia em que me vir obrigado a adoptá-la... para mal dos meus pecados, esse dia está cada vez mais perto.

Abraços,
  Gama Franco

Money, Money, Money...

Parece que hoje tirei o dia para elogiar a Microsoft, mas penso que é tudo coincidência.

Acabei de descobrir o Microsoft Money, e pela apresentação disponível na página parece muito útil. Pode ser que seja desta que vou dizer adeus aos desequilíbrios orçamentais... ou talvez não.

Abraços,
  Gama Franco

Autenticação em VB 2005

Neste artigo é apresentado o funcionamento do sistema de autenticação em VB 2005. Mais uma vez a Microsoft prima por tornar simples aquilo que é comum.

Abraços,
  Gama Franco

Dezoito

O Luís Pedro está a ‘blogar’. Trata-se de um grande amigo meu, ex-colega do projecto ATLAS a fazer doutoramento na Suiça.

Abraços,
  Gama Franco

Replicação a quanto obrigas.

Bom, ok. Ainda há muito trabalho a fazer.

O MySql tem duas formas de replicação, uma Master/Slave e outra através do MySql Cluster. Sendo que nenhuma delas suporta chaves estrangeiras,  e a primeira requer um ‘exclusive lock’ à base de dados. Entre muitas outras limitações...

É tudo, apeteceu-me desabafar.

Abraços,
  Gama Franco

SCI Sockets

Hoje estava a ler uma documentação quando deparei com uma tecnologia que me era desconhecida: SCI Sockets.

Através da mailing list do emprego alguém me iluminou, e para que não passem pela “vergonha” de ter que perguntar aqui vai um ajuda.

Abraços,
  Gama Franco

Footloose.

Definitivamente há artigos que me deixam completamente pasmado. Começa a ser difícil encontrar publicações que tomam abordagens que rompem por completo com os conhecimentos adquiridos ao longo dos anos. Mas este fim-de-semana tive que ler um artigo sobre o Footloose. Genial!

Acredito que alguns destes trabalhos só são possíveis quando uma pessoa se abstrai por completo das abordagens insistentemente tomadas pela maioria das propostas. Ou então talvez não. Talvez existam pessoas tão geniais que nem consigo imaginar o que lhes vai na cabeça.

Seja como for, imaginem um sistema que permite o seguinte: O frigorifico do Manuel repara que as cervejas estão a acabar. Como não costuma comunicar com o PDA do Manuel, mas sabe que esta máquina costuma estar várias vezes perto do microondas, o frigorifico decide enviar uma mensagem a este dispositivo. Mais tarde o Manuel chega a casa, e como de costume coloca o PDA perto do microondas. O microondas informa o PDA que as cervejas estão a acabar, e este último coloca cervejas na lista de compras do supermercado. Quando o Manuel for comprar as suas merecerias encontrará na sua lista as cervejas.

É este tipo de problemas que o Footloose resolve, e mais um ou outro caso particular. Esta tecnologia propõe uma solução para gerir a informação que esteja centrada em apenas um utilizador, sem que ele tenha uma intervenção directa nesta tarefa.

Bom, já vos deixei com água na boca. Fica agora aqui o link para o artigo. Espero que fiquem tão surpreendidos como eu.

Abraços,
  Gama Franco

Um pouco de gestão.

Para quem está interessado em gestão de projectos, aqui vão 10 dicas importantes para o sucesso.

Abraços,
  Gama Franco

AJAX para JSP

Seguindo o artigo “Moda Outono/Inverno”, venho anunciar que foi finalmente lançado o COTS ‘AjaxTags 1.0’.

Tal como o nome indica, esta biblioteca introduz alguns ‘tags’ nas JSPs para manipular pedidos AJAX. Este componente visa facilitar a vida em quem desenvolve ‘Rich Client Web Applications’ com recurso a JSP.
Mesmo para quem não tem esta tarefa vale a pena dar uma olhada.

Um abraço,
  Gama Franco

Papel electrónico

No Slashdot é feita referência a dois artigos (aqui e aqui) sobre a invenção de um tipo de papel electrónico. Isto irá certamente revolucionar num futuro próximo a forma como os jornais estão disponíveis num futuro próximo, uma vez que já é possível produzir este tipo de produtos a cerca de 30£ o metro quadrado. Agora pensem o que pode fazer ao vosso portátil se o contraste for mesmo o que eles vendem.

Um abraço,
  Gama Franco

RFC (Request for comments)

Tenho visto pelas estatísticas do Google AdSense que este blogue começa a ter um número considerável de consultas diárias. No entanto não tenho recebido comentários nenhuns, o que torna difícil a adaptação dos conteúdos com o perfil de quem cá costuma vir.
Por isso, meus amigos, deixem aqui alguns comentários. Digam de vossa justiça o que acham, para eu saber se vale ou não a pena dar-me ao trabalho de colocar aqui um post de vez em vez.

Mesmo para o pessoal que lê o blogue com recurso a um gestor de RSS. Façam este pequeno esforço. Venham à página e deixem aqui um comentário. Digam o que vos vai na telha, terei muito prazer em saber o que se passa dentro dessas cabecinhas. :)

Um abraço,
Gama Franco

Saber onde apostar é uma mais valia

José Figueiredo, professor auxiliar da Universidade do Algarve, escreveu um artigo onde enumera dez tecnologias que deverão emergir no futuro. Para quem deseja (e tem o que) investir isto será um bom ponto de partida.

Um abraço,
  Gama Franco

Moda Outono/Inverno

No artigo anterior vimos como se podiam consumir pedidos de XML via JavaScript. Este é um tópico que está na moda por uma razão muito simples: AJAX. Esta tecnologia (é mais uma metodologia) encontra-se em forte expansão nos dias que passam, tudo graças a algumas aplicações como o Google Mail ou o Flickr.

Para saberem o básico sobre este tópico (e garanto que não é tempo gasto em vão), aconselho vivamente a leitura deste artigo. Vão ver que afinal o conceito até é simples, e vai surgir a questão: Porque raio não se utiliza isto à mais tempo?

Um abraço,
  Gama Franco

Web Services via JavaScript

JavaScript. Ora aí está uma tecnologia horrível, incoerente e difícil de depurar (odeio esta palavra). No entanto é o que temos para desenvolvimento 'client side', e quando não se tem acesso a uma framework decente como ASP.Net ou Struts a sua utilização pode-se tornar incontornável. Ou seja, por vezes temos mesmo que recorrer a JavaScript. Neste artigo é feita uma demonstração de como se podem consumir WebServices nesta tecnologia. Se alguma vez tiverem que utilizar este método já ficam com uma ideia, de qualquer maneira desejo-vos boa sorte. As experiências que tive anteriormente com JavaScript deram-me cabo dos nervos.

Operações com Threads em Java.

Quando se trabalha com Threads em Java utiliza-se geralmente a keyword synchronized. Esta keyword indica que para aceder a um determinado método, o Thread tem que adquirir um lock. O que eu não sabia é que existe outro mecanismo que também permite manter a coerência entre vários processos leves, com recurso a uma técnica diferente. Vejam este artigo para descobrir qual é e quais as suas vantagens/desvantagens.

...e a vida fica mais fácil.

Ora aqui está uma daquelas ferramentas que nos poupam muito trabalho. O Applications Manager permite monitorizar uma variedade de sistemas com recurso a apenas uma aplicação de administração. Entre estes sistemas incluem-se JBoss, Tomcat, SQL Server, IIS, IBM WebSphere, Oracle, MySql e muitos outros. Uma lista completa dos sistemas suportados está disponível nesta página.

Existem duas versões desta aplicação, uma gratuita e outra paga. A gratuita permite monitorizar até 5 sistemas durante um período ilimitado. Ou seja, o ideal para quem tem um pequeno negócio ou trabalha numa empresa de pequena dimensão. Outra divergência em relação à versão paga é a ausência de actualizações e a possibilidade de suporte apenas por E-mail.

Um abraço,
  Gama Franco

Uma questão simples sobre segurança.

É um dado adquirido que grande parte das aplicações multi-utilizador têm algum mecanismo de identificação. Na maior parte dos casos este mecanismo resume-se à identificação de um utilizador através de um identificador único e uma password. Geralmente o identificador único é um ‘username’, ou algo idêntico.

No entanto alguns programadores não levam em conta que a base de dados onde se armazenam as palavras-passe, podem ser consultadas com recurso a técnicas muito simples para obtenção de acesso não autorizado. Algumas dessas técnicas estão muito bem documentadas, e um programador menos experiente terá pouca dificuldade em as utilizar.

Disto isto, parece óbvio que a informação mais sensível deverá ser codificada, ou melhor ainda, ser armazenada com recurso a técnicas que permitam a identificação sem se guardar a palavra-chave original.

Mais uma vez, irei recorrer a um artigo para explicar este ponto de vista. Nele são apresentadas algumas técnicas, e é exemplificada a sua utilização com recurso a tecnologia da Oracle. No entanto as ideias apresentadas podem ser utilizadas em qualquer plataforma de desenvolvimento.

Um cheirinho de Robótica.

Apesar de não ser a minha área, não deixei de achar este link interessante. Tem um excelente tutorial de como se pode construir protótipos de autómatos (Robots) rapidamente.

Para os mais interessados, vejam também este link. Aqui fala de que forma se pode construir um robot que se pode controlar através de tecnologia ‘wireless’.

Um abraço,
  Gama Franco

Filme de Terror

Passei a tarde de domingo a ver 'The Shining', um filme de terror realizado pelo mestre Stanley Kubrick. Mas o verdadeiro terror aconteceu quando desliguei o meu velhinho VHS e vi as previsões da RTP1 para as Autárquicas. Isaltino, Valentino e Fátima fazem parte dos eleitos...

Acho que em Kuala Lumpur estão a precisar de profissionais de TI.

Um abraço,
Gama Franco

Pensamento do dia

"If at first you don't succeed, find out if the loser gets anything."
Bill Lyon

Balde de água fria pela manhã.

Aqui vai um balde de água fria para quem pensa que não existe diferença para  a palavra “protected” entre Java e .Net. É engraçado porque pensava que o efeito era igual para ambas as tecnologias. Espero que não fiquem tão surpreendidos como eu.

Um abraço,
  Gama Franco

Linux chega aos portáteis

A CNET tem um artigo onde informa que a Dell passou a ter disponível um portátil com a distribuição de Linux Mandriva.

É interessante, lembro-me de ler num artigo de opinião do Linux Journal que isto seria um enorme passo em frente para este sistema operativo. Se tivermos em conta que o artigo tem mais de dois anos, esta notícia peca por ser tardia. No entanto não deixa de um marco.

O curioso é que o artigo de opinião referia que isto iria acontecer por exigência de uma grande empresa (que decidia baixar o custos de aquisição de equipamento), e que os fabricantes de portáteis teriam uma grande guerra pela frente para ganhar o contracto. O fabricante vencedor ficaria de costas voltadas com a Microsoft, mas estava atravessada a barreira. A partir daí seria uma guerra aberta para fazer chegar ao consumidor final soluções baseadas neste sistema operativo, ameaçando a hegemonia do gigante de Redmond. Afinal não é isto que está a acontecer, e parece que talvez exista uma lacuna no mercado de consumo. Ou talvez não, e nesse caso não irá haver procura para este tipo de produtos, deixando esta primeira iniciativa condenada ao fracasso.

Provavelmente só o futuro irá dizer, e não está tão distante quanto isso.

Um abraço,
  Gama Franco

JUnit4

Elliotte Rusty Harold fez um resumo acerca da nova versão do JUnit (versão 4). Para quem não conhece, trata-se de uma framework para testes unitários em Java.

Esta nova versão tem algumas inovações em relação à versão 3.8, algumas delas fortemente inspiradas no NUnit (biblioteca para testes unitários para .Net). Das novas alterações gostaria de realçar o facto de os testes tirarem agora partido das anotações, introduzidas no Java 1.5. Além disso agora é permitido fazer classes de testes que não derivam de TestCase. A vantagem? É simples, agora podemos ter uma classe de testes que deriva da classe que pretendemos testar, o que permite testes a métodos ‘protected’.

Vale a pena dar uma olhada para ver o que se pode esperar desta nova versão. Estou certo que vai dar muito que falar (ainda está em beta).

Um abraço,
  Gama Franco

Como vai o open source?

Quem me conhece sabe que tenho um carinho especial por Linux e o universo open source. No entanto confesso que estou um bocado desiludido pelo facto de ter sido prometida muita coisa à volta deste sistema, e os passos têm sido dados a um ritmo demasiado lento. Mas os progressos vão sendo feitos, principalmente com o aparecimento de algumas empresas a seguirem uma filosofia POSS (Professional Open Source Software). Tomando por exemplo MySQL, JBOSS, etc.
Também já fui mais radical, mas talvez se tenha devido ao facto de desconhecer as soluções proprietárias. Há áreas onde a Microsoft está a fazer um excelente trabalho, e os progressos impulsionados por esta empresa são de louvar (i.e. Business Intelligence).

Gostaria de salientar que os países onde a tecnologia tem tido mais sucesso encontram-se no hemisfério sul, os denominados países em vias de desenvolvimento. Portugal tem ainda muito que evoluir nesta matéria, e penso que o facto de ser prática comum a aquisição de software proprietário a custo zero através de práticas ilegais (P2P) prejudica a adopção de plataformas alternativas. Quem é que está disposto a fazer a migração de uma suite de Office numa PME, se é possível obter a custo zero a solução da Microsoft com riscos praticamente nulos? E qual a probabilidade de captar recursos para desenvolver em Unix/Linux se a maior parte dos técnicos sempre teve em casa versões proprietárias pelas quais não pagou? Ou se pagou este preço já vinha incluído no seu desktop, uma vez que os grandes fabricantes não têm por política a distribuição de raiz de software gratuito que iria baixar o preço do produto final.

Depois podemos também levantar a questão do tempo que leva a desenvolver aplicações para cada uma destas plataformas. Acredito que o Time to Market de uma solução .Net seja inferior a outra baseada em Java, que pode ser desenvolvida por inteiro recorrendo a tecnologias gratuitas (e que corre em qualquer sistema). No entanto o que interessa ponderar na maioria dos projectos é o retorno do investimento (ROI). Será que pelo facto de eu introduzir no mercado algumas semanas antes um produto cujo investimento foi muito superior terá um maior retorno? Nalgumas situações sim, noutras não. Além disso posso sempre cortar os valores das licenças e meter mais um programador no projecto. Desta forma o investimento fica retido no nosso país, o que é mais saudável para a economia nacional. Mas mais uma vez, na maioria dos casos temos a PME a comprar uma licença e a disponibilizar o software para N programadores. Desta forma não há ROI que aguente!

E temos ainda o problema do suporte. Mas este começa a ser cada vez mais um mal menor. A maioria das alternativas no mercado tem geralmente esta opção (paga). Agora será que compensa? Ora vejamos, se tiver uma licença de SIEBEL para um ambiente de desenvolvimento, outra para o de testes e mais uma para produção, e ao fim disso tudo desembolsar um determinado valor para obter suporte do fornecedor chego (claramente) a um valor exorbitante. Por outro lado posso sempre fazer o download (gratuito) do SugarCRM, fazer a instalação nos três ambientes e pagar (apenas) pelo suporte. Infelizmente não é fácil arranjar técnicos no mercado para SugerCRM, mas para SIEBEL também não! Além disso se subirmos a fasquia para bom/muito bom ficamos reduzidos a meia dúzia.


Para finalizar, e foi isto que me despertou o interesse por colocar aqui este pensamento, aconselho a leitura deste artigo de opinião. Aqui são apresentadas 5 razões para não se utilizar Linux. Não deixa de ter alguma piada.



Um abraço,
  Gama Franco

Comparação entre Web Services e .Net Remoting (ou Java RMI)

Neste artigo é apresentada uma breve comparação entre .Net Remoting e Web Services. O objectivo é simples, ajudar a determinar quando é que se deve optar por uma solução em detrimento da outra. O artigo é pequeno, pouco detalhado mas sempre dá algumas luzes aos menos esclarecidos nesta matéria.
Pela minha experiência sei que esta comparação também é valida quando feita entre Java RMI e Web Services.

Agile vs resto do mundo (Round I)

Felizmente, durante estes dois últimos anos, consegui absorver algum conhecimento em dois projectos que seguiram metodologias opostas. Para o primeiro (projecto A) foi utilizada uma metodologia baseada em Análise Orientada aos Objectos (OOA, recurso a UML). No segundo (projecto B) foi adoptada uma metodologia ágil (eXtreme Programming).
Na primeira parte deste artigo vou apresentar uma breve descrição das metodologias adoptadas em cada projecto. Na segunda irei fazer uma pequena comparação entre estas duas metodologias, enumerando as vantagens e desvantagens de cada uma delas. É claro que será apenas uma comparação baseada na minha experiência pessoal, ausente de qualquer justificação científica.

Na primeira fase do projecto A houve um levantamento de requisitos, seguido das fases de análise, desenho da arquitectura, implementação, testes e finalmente a entrada em produção. Este processo foi efectuado em espiral, ou seja, existiram sucessivas iterações entre a fase de análise e as que a sucedem.

O projecto B teve um processo de desenvolvimento bastante diferente. Existiu uma pequena fase de análise com os principais objectivos de se definir qual a tecnologia a utilizar, elaborar um calendário com diversas ‘milestones’ e acordar as linhas orientadoras do processo. Após esta breve fase começou-se o desenvolvimento, puro e duro.
Antes de se fazer uma linha de código criava-se um teste unitário (Unit Test). Se o teste falhasse (o mais comum) fazia-se o desenvolvimento da funcionalidade, e em seguida fazia-se o ‘refactoring’ do código. Depois corriam-se os testes unitários na totalidade para verificar se não se estragou nada do que estava feito até à data.
Os ‘milestones’ acordados na primeira fase foram Feature Complete (FC), Zero Bugs Bounce (ZBB), Beta 1, Beta 2 e finalmente Final Release. Em baixo faço a descrição de cada ‘milestone’.

FC: todas as ‘features’ foram terminadas até esta data, ou seja, a partir deste ‘milestone’ apenas se catalogaram e corrigiram ‘bugs’. Gostaria de realçar que neste projecto nem todos os ‘bugs’ foram resolvidos. Foi feita uma selecção de quais valeria a pena resolver ponderando a sua criticidade e os efeitos secundários da sua resolução. Além disso tentou-se sempre atrasar a resolução de um bug o mais possível, assim garantíu-se que as tarefas mais importantes eram sempre realizadas primeiro. Alias, esta filosofia aplicava-se também às ‘features’, mas este comportamento é comum a quase todas as metodologias que eu conheço.

ZBB: Quando este ‘milestone’ foi atingido os bugs a resolver tinham no máximo 24 horas. Ou seja, era obrigatório que todos os ‘bugs’ reportados num dia fossem resolvidos no dia seguinte, caso se optasse pela sua resolução.

Beta 1: Primeira versão a enviar para produção num grupo restrito de clientes. Aqui foram feitos testes de integração e de aceitação.

Beta 2: Versão para substituir a anterior no mesmo universo de clientes.

FR: “Abram uma garrafa de ‘Don Perignon’ e metam na conta do chefe”.

Para finalizar, gostaria de notar duas particularidades acerca desta metodologia.

• O cliente faz parte da equipa de desenvolvimento.


• As ‘features’ são acordadas através de ‘User Stories’

Isto quer dizer que o próprio processo de desenvolvimento é feito em ciclos muito curtos, e o projecto tem o comportamento de um protótipo evolutivo. Pode-se observar as fases de cada ciclo neste diagrama (autoria de J. Donovan Wells).

No próximo artigo irei fazer a prometida comparação entre estas duas metodologias, focando alguns pontos comuns em qualquer projecto. Será uma experiência realmente interessante, porque apesar do objectivo passar sempre por entregar um produto final no prazo acordado e deixar o cliente satisfeito, estas duas metodologias seguem filosofias opostas.

Gostaria apenas de salientar que irei fazer uma comparação tendo em conta o seguimento destas metodologias tal como foram descritas. Projectos com duração considerável sofrem sempre de alguns imprevistos, e quer num caso quer no outro não foram feitas análises de risco. Quando os imprevistos aconteceram... improvisou-se.

Também vou salientar que o um dos projectos ainda está a decorrer, e eu já não sou membro da equipa. O que quer dizer que na segunda parte do artigo irei especular acerca da sua conclusão, supondo sempre que esta será um sucesso (acredito que sim pois a equipa é liderada por pessoas com grandes capacidades nesta área).

Mais uma da autoria de Joel Spolsky

Joel Spolsky, o líder da empresa “Frog Creek Software” que utiliza uma estratégia revolucionária de recursos humanos, escreve neste artigo uma pequena comparação entre os métodos ágeis e os processos de desenvolvimento centrados na documentação. Este artigo é baseado na sua opinião pessoal, e não é alvo de uma comparação com resultados objectivos. No entanto considero uma leitura interessante para quem, tal como eu, tem dúvidas acerca de qual será a melhor abordagem para um determinado projecto. Infelizmente o artigo serve apenas para aumentar as dúvidas, mas de qualquer forma não deixa de ser uma leitura interessante.

No artigo está também uma ligação para a especificação de uma ferramenta de software desenvolvida por esta empresa. Trata-se de um documento com alguns detalhes técnicos interessantes.

PS: Aconselho vivamente a leitura regular deste blogue.

Um abraço,
Gama Franco

Maldita preguiça!

Já à algum tempo que me dá a preguiça para deixar aqui algumas ideias. Acho que posso justificar a minha falta de pró-actividade (palavra da moda nos dias que correm) com a época que estamos a passar. Este mês de Agosto não dá vontade fazer o que quer que seja. Parece que sou contagiado pelas férias dos outros, já que as minhas foram tão curtas que quase nem me lembro delas.

Para quebrar esta monotonia vou deixar aqui um breve ‘post’, de leitura fácil para recomeçar aos poucos a publicar alguma coisa. A leitura que vos proponho é uma entrevista ao autor de mais um livro de ‘Agile Project Management’, vulgo APM.

Aconselho a sua leitura numa pausa de cinco minutos antes do almoço, para abrir o apetite ;)

Um abraço,
   Gama Franco

Uma questão de Inteligência.

É comum revoltarmo-nos com um determinado jogo simplesmente porque a Inteligência Artificial não é lá grande coisa. A maior parte das vezes apenas somos batidos pela máquina porque esta conta com algumas facilidades, como por exemplo a produção de recursos a uma velocidade superior. Outras vezes levamos autênticas tareias porque os autores decidiram colocar o oponente com o dobro de recursos em relação ao jogador.

Isto acontece porque os algoritmos de inteligência artificial são programados a priori, e geralmente o oponente não consegue adaptar-se aos diversos comportamentos imprevisíveis do jogador. Quantas vezes não chegamos a vencer o computador utilizando sempre a mesma táctica do princípio ao fim do jogo?

Mas existe esperança para um futuro melhor. Um grupo de investigadores da Universidade do Texas encontra-se a produzir um jogo com um conceito novo. Nele o jogador é convidado a treinar um conjunto de agentes a reagir a determinadas situações, e depois poderá observar o seu comportamento em batalhas contra agentes treinados por outros jogadores.

Os agentes são treinados com recurso a Redes Neuronais, e o aperfeiçoamento da população é feita através de Algoritmos Genéticos. A ideia não é nova, mas nos produtos existentes no mercado o jogador tinha sempre que desenvolver a inteligência artificial dos agentes. Neste caso são os agentes que aprendem as tácticas indicadas pelo jogador. Talvez num futuro próximo tenhamos um PC à nossa altura.

Tenho esta mania...

Geralmente quando descubro uma ferramenta nova e esta é proprietária, tenho por hábito procurar uma com as mesmas funcionalidades e licença open source. É uma daquelas manias, e às vezes até descubro umas coisas engraçadas.

Para quem sofre da mesma doença, aqui vai uma lista bastante completa.

Um abraço,
Gama Franco

Oracle e os Database Links para... a concorrência.

Quem já trabalhou com bases de dados distribuídas, certamente já ouviu falar em 'Database Links' (DBLinks). Em Oracle um DBLink permite que o utilizador venha a aceder a uma tabela numa base de dados remota da mesma forma que acede a uma tabela local.

O que eu não sabia (chamem-me ignorante) é que o Oracle permite que se crie um DBLink para uma tabela numa base de dados de um DBMS da concorrência (i.e. MySQL, SQL Server, etc...).

Está tudo aqui.

Um abraço,
Gama Franco

EXISTS, IN e NULL

Ora aqui está um daqueles artigos que servem para tirar algumas dúvidas base.

Quando se aprende uma tecnologia nova, há alguns pontos que passam despercebidos, e levam-nos mais tarde a perder algum tempo de volta do google para clarificar algumas dúvidas subtis. O artigo em causa fala do comportamento dos operadores EXISTS e IN acerca de valores NULL.

Espero que vos seja esclarecedor tanto quanto foi para mim.

Um abraço,
Gama Franco

Os testes e o modelo de dados.

O modelo de dados é certamente uma das partes mais importantes de qualquer projecto, e é geralmente o ponto de partida da fase de desenvolvimento. Também é comum destacar-se uma camada para aceder a esses mesmos dados. No caso do Java, a maioria das vezes, utiliza-se o modelo ‘MVC’, cabendo à camada ‘Model’ esta tarefa. Nas arquitecturas de .Net a camada equivalente é denominada de ‘DataAccess’.

Quem utiliza métodos ágeis depara sempre com o mesmo problema no início de qualquer projecto: “Como é que vou testar a camada de acesso aos dados sem introduzir alterações na base de dados de testes?”
Esta dúvida surge porque, se estamos a testar a inserção dos dados de clientes num teste unitário, e noutro a verificar o número de clientes que existem no sistema, é certo que o segundo vai falhar se correr depois do primeiro. Desta forma está-se a violar o princípio do ‘Isolamento’.
Neste artigo irei sugerir uma técnica que permite testar a interacção entre o nosso programa e o modelo de dados, sem que se viole o isolamento dos testes de regressão.
A filosofia desta técnica consiste em registar todos os acessos numa única transacção, e depois de verificadas todas as condições, forçar o ‘rollback’ da mesma.

Por questões de simplicidade o exemplo será apresentado em Java recorrendo a uma ligação JDBC para MySql, mas a sua utilização em C# ou noutra linguagem orientada aos objectos é análoga. Gostaria apenas de realçar que para se utilizar esta técnica é necessário que o ‘DBMS’ ou a ‘Framework’ suporte transacções. Para uma arquitectura em Java com MySql é obrigatória a utilização de tabelas do tipo ‘INNODB’ por ser o único que suporta transacções. Alternativamente pode-se recorrer a um contentor de ‘EJBs’ que garanta a transacção ao nível da ‘Framework’.
Para a tecnologia .Net a minha preferência resume-se à utilização do ‘Distribucted Transaction Manager’, e efectuar manualmente a gestão das transacções.

Em primeiro lugar é necessário encapsular a ligação à base de dados utilizada, desta forma ficaremos com a classe:

public class Database implements IDatabase
{
  private Connection connection;
  private boolean transactionStarted = false;

  public Database(String databaseName, String username, String password)
     throws ClassNotFoundException, SQLException
  {
     Class.forName("org.gjt.mm.mysql.Driver");
     connection = DriverManager.getConnection(...);
  }

A nossa classe irá implementar um Interface que apresenta todos os seus métodos públicos, e a ligação à base de dados é feita no construtor. A forma como a ligação é feita é irrelevante, e pode-se optar por ler os dados da ligação de um ficheiro de configuração.

  public Connection getConnection()
  {
      return connection;
  }

  public void beginTransaction()
     throws TransactionAlreadyStartedException, SQLException
  {
     if (transactionStarted)
        throw new TransactionAlreadyStartedException();
     setTransactionStarted(true);
     connection.setAutoCommit(false);
  }

  public void commitTransaction()
     throws TransactionNotStartedException, SQLException
  {
      if (!transactionStarted)
          throw new TransactionNotStartedException();
      connection.commit();
      connection.setAutoCommit(true);
      setTransactionStarted(false);
  }

  public void rollbackTransaction()
     throws TransactionNotStartedException, SQLException
  {
      if (!transactionStarted)
          throw new TransactionNotStartedException();
      connection.rollback();
      connection.setAutoCommit(true);
      setTransactionStarted(false);
  }

  public boolean inTransaction()
  {
      return transactionStarted;
  }

O método getConnection() retorna a ligação que se está a utilizar, mas é importante garantir que o nosso código não vai executar métodos que afectem o estado das transacções. Eu optei por esta forma por questões de simplicidade, mas se quisermos ser rigorosos teremos que utilizar uma técnica em que a ligação não seja exposta publicamente.

 
  protected void setTransactionStarted(boolean transactionStarted)
  {
      this.transactionStarted = transactionStarted;
  }
}

Este método será utilizado para se iniciar uma nova transacção.

Em seguida iremos criar uma 'Factory', por duas razões. Em primeiro lugar queremos garantir que apenas existirá um objecto do tipo Database no nosso programa, depois porque mais tarde iremos substituir este objecto por outro sem que o nosso programa se aperceba disso.

public class DatabaseFactory implements IDatabaseFactory
{
   private IDatabase database;
   private ILog log;
  
   public ModelFactory() throws ClassNotFoundException, SQLException
   {
   }
  
   public setDatabase(IDatabase database)
   {
       this.database = database;
   }

   public IDatabase getDatabase()
   {
       return database;
   }
}

Esta classe é bastante simples, e penso que dispensa comentários.

Agora falta arranjar uma forma que permita ao nosso programa localizar a factory disponível, por forma a obter a ligação. Eu optei pelo padrão 'Service Locator', mas existem outras técnicas válidas.

public final class Services {
  
   private static IModelFactory modelFactory;
  
   private Services() {
   }
  
   public static IModelFactory geModelFactory()
   {
       return modelFactory;
   }
  
   public static void setModelFactory(IModelFactory factory)
   {
       modelFactory = factory;
   }
}

No ponto de arranque do nosso programa procede-se à configuração da classe Services, para podermos disponibilizar as fábricas que serão utilizadas durante a execuçãp. Neste exemplo apenas temos uma 'Factory' mas é comum existir pelo menos uma por camada.

Agora que temos o nosso ambiente de desenvolvimento completo, podemos começar a trabalhar uma classe que irá aceder aos dados. No entanto, à boa maneira ágil, iremos começar pelos testes :)
O nosso objectivo é registar um cliente e a sua morada, estando estes dados em tabelas diferentes (o exemplo poderia ser melhor, mas estou com falta de imaginação). Por questões de simplicidade o cliente é apenas composto pelo seu nome, a morada pela localidade e não irei utilizar sequências nas tabelas (o nome é a chave).

Nos testes iremos substituir a classe Database por uma outra cuja transacção não seja efectuada. Assim teremos uma classe de nome DatabaseTestInstance para ser utilizada exclusivamente nos testes.

   
public class DatabaseTestInstance extends Database implements IDatabase
{
   public Database(String databaseName, String username, String password)
       throws ClassNotFoundException, SQLException
   {
       super(databaseName, username, password);
       getConnection().setAutoCommit(false);
   }

   public void commitTransaction()
       throws SQLException, TransactionNotStartedException
   {
       rollBackTransaction();
   }
  
   public void rollBackTransaction()
       throws SQLException, TransactionNotStartedException
   {
       super.rollbackTransaction();
       getConnection().setAutoCommit(false);
   }
}

Como podemos observar, o contrutor desta classe desliga o modo 'auto-commit' e faz sempre 'rollback' quando uma transacção termina.

Passando ao teste propriamente dito temos:

public class ClientTest extends TestCase
{
   private IClientModel clientModel;

   public TestBase(String name) throws ClassNotFoundException, SQLException
   {
       super(name);
       IDatabaseFactory databaseFactory = new DatabaseFactory();
       modelFactory.setDatabase(
               new model.tests.unit.injections.Database
                      ("database", "user", "pass"));
       Services.setModelFactory(databaseFactory);
   }

Aqui pode-se observar que estamos a substituir a classe que representa a ligação por uma classe de testes. A este conceito dá-se o nome de 'Dependency Injection'.

   public static junit.framework.Test suite()
   {
       junit.framework.TestSuite suite =
             new junit.framework.TestSuite(MillionaireTest.class);
       return suite;
   }

   protected void setUp() throws java.lang.Exception {
       super.setUp();
       clientModel = new ClientModel();
   }

   public void testInsertClient() throws SQLException {
       clientModel.InsertClient("Maria", "Lisboa");

       IDatabase database = Services.getDatabaseFactory().getDatabase();
       Statement statement = database.getConnection().createStatement();
       String query = "SELECT count(*) as count " +
                      "FROM clients, local" +
                      "WHERE name like 'Maria'";
       statement.execute(query);
       ResultSet result = statement.getResultSet();
       result.next();

       assertTrue("Client not inserted.", result.getInt("count") == 1);

       result.close();
   }

Este teste verifica a inserção de um novo cliente. O próximo testa se o número de clientes na tabela é o esperado.

public void testCountClients() throws SQLException {
       assertIsTrue("Number of clients is not the expected",
           clientModel.countClients() == 10);
}

Desde já pode-se verificar que se o isolamento entre os testes não se verificar, correr testInsertClient e depois testCountClients é diferente de correr testCountClients e depois testInsertClient.

Agora que temos os testes, falta apenas programar a classe ClientModel:

public class ClientModel implements IClientModel
{
  
   private final String GET_NUMBER_CLIENTS = "SELECT count(*) as count " +
                                             "FROM clients";
  
   private final String INSERT_CLIENT = "INSERT INTO clients VALUES(?)";
  
   private final String INSERT_LOCAL = "INSERT INTO local VALUES(?, ?)";

   public ClientModel()
   {
   }
  
   public int countClients() throws SQLException
   {
       IDatabase  database = Services.getDatabaseFactory().getDatabase();
       Statement statement = database.getConnection().createStatement();

       statement.execute(GET_NUMBER_CLIENTS);
       ResultSet result = statement.getResultSet();
       result.next();

       int numberOfClients = result.getInt("count");
       result.close();

       return numberOfClients;
   }

Note-se a subtileza da declaração da variável 'database'. O valor atribuído a esta variável é o que a fábrica retornar, e é isso que torna possível substituir a ligação à base de dados sem que o programa tenha conhecimento.

Agora o método em falta:

   public void insertClient(String clientName, String local)
       throws SQLException, InvalidValueException, ModelException
    {
       IDatabase  database = Services.getDatabaseFactory().getDatabase();
       Statement statement = database.getConnection().createStatement();

       try {
           db.beginTransaction();
           insertClient(clientName);
           insertLocal(local, clientName);
           db.commitTransaction();
       }
       catch (TransactionException e)
       {
           throw new ModelException(e);
       }
    }
    ...

Deixo por implementar os métodos insertClient e insertLocal. De qualquer forma, é possível verificar que o comportamento de db.commitTransaction() é diferente caso se esteja em testes ou a executar o programa.


Resumo:
Verificámos como é possível garantir o isolamento dos testes unitários no que diz respeito à utilização de um modelo de dados. Para isso tivemos que encapsular a ligação numa classe, utilizar uma fábrica e injectar as dependências através de um 'service locator'.
Gostaria ainda de realçar que esta técnica funciona se o nosso programa não efectuar vários pedidos ao DBMS em simultâneo (i.e. não efectuar transacções concorrentes). Além disso, se acima da camada de acesso aos dados necessitar de iniciar transacções, esta técnica deve ser aplicada nessa camada também. Para evitar problemas futuros, é aconselhável começar transacções sempre na mesma camada.

Um abraço,
Gama Franco

Da Web para a Net.

Quem tem o vício de subscrever 'RSS' e está constantemente a trocar de 'PC' ou a formatar a sua máquina habitual, certamente deparou com o problema de colocar novamente a sua lista em funcionamento. A maior parte das aplicações podem exportar a lista para um determinado formato mas não deixa de ser um procedimento aborrecido, e corre-se sempre o risco de formatar a máquina antes de se lembrar que havia uma lista de 'RSS' para copiar. Já para não referir aqueles caso em que acontece uma catástrofe a ao PC, mas também quem é que não faz 'Backups'???

Aconteceu-me que tinha uma lista considerável de 'Blogs' e afins no computador onde trabalhava até à um mês e meio, e esta lá ficou. Como tive que refazer a lista, decidi que desta vez iria utilizar uma página na Internet para o efeito. Antes de deitar mãos à obra, fiz uma pesquisa no 'Google' para ver se alguém teve uma ideia semelhante à minha (acontece sempre). Depois deparei com o 'Bloglines'. Este serviço permite organizar uma lista de 'RSS', mas tem outras funcionalidades, das quais gostava de destacar duas delas.

A primeira permite a visualização de uma lista de 'Blogs' com o mesmo contexto de um que se esteja a seguir. Já encontrei alguns 'sites' interessantes à custa desta funcionalidade.
A outra funcionalidade que gostaria de destacar é a facilidade com que partilhamos a nossa lista de 'RSS', ora vejam.

Adicionalmente existem também uma variedade de 'plugins' que permitem receber notificações quando um novo artigo é colocado num 'site' da nossa lista. Cheguei mesmo a instalar um para o 'Firefox', mas este não funcionou como eu esperava...

Agora só estou à espera de um pouco de paciência para tentar aplicar esta técnica à minha lista de favoritos. Sempre me agradou a ideia de ter os recursos disponíveis na internet em vez de na própria máquina. Páginas como o 'Bloglines' são sempre de grande utilidade.

Um abraço,
Gama Franco

O custo de uma boa variável.

Desde os primeiros anos de faculdade que participei em várias discussões sobre qual o nome a dar a uma determinada variável. Na realidade, os meus primeiros programas tinham sempre algo do tipo:

char *cstmr;

Que com muita imaginação se pode perceber que nesta variável iria guardar o nome de um cliente. É claro que conforme ia introduzindo 'bugs' nos meus programas passava a dar mais valor ao nome das variáveis, mas depois surgia a dúvida sobre o tipo de notação a utilizar:

char *costumer_name;

ou

char *costumerName;

ou ainda

char *CostumerName;

Na realidade estas acabavam por ser discussões inúteis, que nada contribuíam para a celeridade do trabalho. Muitas vezes a filosofia da tecnologia com que se está a desenvolver já tem algo a dizer sobre a notação que utilizar, mas quando isso não acontece acho que a única coisa importante é que todos os elementos do projecto sigam a mesma regra.

Mas apesar disto houve algo que me passou despercebido até ler este artigo, da autoria de Joel Spolsky. Nele é sugerida uma notação que facilita a detecção de erros, e creio que todos sabemos a dor de cabeça que é detectar e corrigir bugs. Apesar de ser uma sugestão simples, a sua subtileza surpreendeu-me. Acho que vale a pena perder dez minutos e evitar alguns dissabores.

Aposto que após lerem o artigo ficarão a pensar no custo efectivo de uma má escolha no nome das variáveis, pelo menos foi o que aconteceu comigo.

Um abraço,
Gama Franco

O primeiro e provavelmente o pior.

Como é fácil de verificar este é a primeira entrada no recém-criado "A vida não é um padrão". Sendo novo nestas lides, espero que este seja de todos o meu pior 'post'.

Em primeiro lugar gostaria de registar a razão deste Blog (sei que não será fácil identificar a piadola do nome). "A vida não é um padrão" serve para registar e divulgar algumas leituras importantes que vou encontrando pela 'net', focando-me principalmente nas novas tecnologias e mais precisamente na Engenharia de Software. É possível que numa ou outra altura venha a fugir deste tema, mas espero que seja raro.

Como costuma dizer um amigo meu, "esta coisa de ser Engenheiro Informático é pior do que ser médico". É claro que se refere meramente ao esforço que temos que fazer para nos mantermos actualizados, tendo em conta a velocidade vertiginosa a que esta área evolui. Este facto é mais verdadeiro se notarmos a existência de alguns masoquistas que (tal como eu) se recusam a focar os seus conhecimentos apenas numa tecnologia.

Logo aqui podemos notar dois tipos de abordagem a exercer Engenharia Informática, uma que se foca numa tecnologia e provavelmente fica-se a ganhar um ordenado chorudo antes de se ter filhos, a outra tenta-se saber um pouco de tudo e a probabilidade baixa radicalmente. Esta é a percepção que tenho, e tem muito a ver com a natureza do mercado Português. Mas sobre este tema espero falar mais tarde.

De qualquer forma, pretendo durante os próximos tempos colocar neste local referências aos artigos que acho mais pertinentes, e talvez mais tarde publicar alguns da minha autoria (serão os menos lidos). Isto porque quem perde algum tempo a investigar novas metodologias e tecnologias acaba sempre por apanhar muito lixo pelo meio, porque a boa informação, aquela que marca a diferença, é difícil de encontrar.

Um abraço,
Gama Franco