Novo blog - www.leandromoreira.com.br

Não estou abandonando este blog (eu espero) mas agora também estou postando em um outro blog o Leandro Moreira lá pretendo escrever e abordar assuntos de desenvolvimento de sistemas do mesmo modo que aqui só que em inglês. :) 

A experiência do TDD na vida de um desenvolvedor

Pré-TDD

Um pouco cético quanto ao processo mas estudando e lendo opiniões que fazem sentido, logo você "compra" a ideia. No inicio escreve-se os testes depois que (quase) tudo foi feito e o pior é o vício de escreve-los para que os mesmos funcionem. Nessa fase não se vê nem o beneficio real que os testes unitários trazem (nem mesmo a "metodologia" TDD traz). As perguntas mais freqüentes nessa era são:

Devo testar os CRUD's? Devo testar Getters and Setters simples?

Sintomas: perdendo tempo escrevendo testes (pós-testes)
Ferramentas que conhece: JUnit  :(
Prefere criar um public static void main(String[] args) e usar Alt+Shift+X     +    J ao criar uma ClasseTest com um método anotado com @Test.

Pós-TDD

Você (realmente) sente inseguro quanto olha pra massa de testes e vê que novas (ou antigas) funcionalidades não estão sendo testadas, de alguma forma não ter os testes te causa uma sensação terrível de que está faltando algo. Suas idéias nascem pensando em testes (indo para BDD) você muda mesmo a forma de pensar. Você (realmente) sabe do valor inestimável de se ter testes para rodar antes de um build. Começa a achar estranho o desaparecimento de bugs esporádicos. Tem toda certeza que quase todo pedaço de código pode gerar bug inesperado. Ferramentas que já conhece e não vive sem : Mockito, Maven, Hudson...  Ferramentas que começam a despertar seu interesse: JBehave, Selenium. Claro que algumas dessas ferramentas não estão ligadas diretamente ao TDD mas sim ao modo de pensar em testes e automação dos mesmos. Testes de software é algo complexo, extenso e sempre em evolução mas é uma maneira eficiente de diminuir os erros na criação ou manutenção de software.

Materiais para ajudá-lo na busca pelo TDD
Link: http://improveit.com.br/xp/praticas/tdd/
Livro: TDD by example (traduzido para pt_BR)

só pra lembrar: test fails, test passes, refactor

Novo projeto WetSand

O que estive fazendo...

Estou tentando reduzir meus (re)trabalhos para criação de CRUD's. O resultado desse esforço é a ideia de criar um framework pra aumentar a produtividade na criação de CRUDS. O conceito principal é que você tem uma API e pode provê várias implementações para essa API (W0). Isso tudo não é nenhuma novidade, apenas minha tentativa de padronizar a criação de CRUDS.

WetSand

É o conjunto de projetos para criação de aplicações que vão inevitavelmente ter CRUDs.

W0 - A API base

A arquitetura básica está toda nesse projeto, que é fortemente baseado nos conceitos de Domain-Driven Design (DDD). Infelizmente o conceito de arquitetura de referência é empregado aqui, engessar sua aplicação tem vários efeitos colaterais e más implicações mas foi o jeito que encontrei de "criar" uma estrutura, até certo ponto flexível, para servir genericamente para isso. Resumidamente um arquitetura de referência te força a usar a mesma estrutura para matar uma "barrata" e matar uma "baleia" por outro lado há uma padronização de interfaces e mensagens entre os componentes, o que para a criação de CRUD's pode ajudar muito.

W1 - Primeira implementação JPA 2.0, Spring 3.x.x, JSF 2.0

Para ter mesmo certeza que tal API poderá ser útil, trabalho na primeira implementação dessa API. Essa implementação utiliza JPA 2.0, Spring 3.x.x, JSF 2.0 e Primefaces 2.2.1 dentre suas dependências. Foram criados os subprojetos:

• W10 - A implementação para os Dao's (CrudDao) baseada no JPA 2.0 bem como a implementação da API Query.
• W11 - A implementação base para o CrudRepository.
  
• W12 - A implementação base para o CrudService.
  
• W13 - A implementação base para o ManagedBeanCrudController que é uma especificação do controlador mais genérico CrudController.
  

Em que pé anda...

O projeto exemplo já está rodando mas ainda considero longe de uso em produção ou algo assim, está na fase de evolução. Logo, toda e qualquer sugestão ou crítica será bem vinda. Penso em criar implementações compatíveis para Richfaces 4.0, VRaptor 3, GAE e GWT para realmente testar se é possível que essa API e suas implementações possam diminuir o retrabalho de CRUDS. Também há um gerador de CRUD mas esse é bem específico e a única implementação que tem é para o W1X.

Enfim

Se o projeto não servir de nada talvez ele sirva de exemplo de como construir telas usando JSF 2.0, components do facelets, usar o primefaces, utilizar o Spring 3.x.x juntamente com JPA 2.0, bem como Maven e outras boas práticas de "novas" tecnologias. Logo terá uma documentação básica com um Quick Start e demonstração de exemplos.

Segurança, CCC, Assinatura digital, Consoles...

O CCC - Chaos Computer Club promoveu, esse ano, um evento que mostrou muitos fatos interessantes. Em uma das apresentações o grupo fail0verflow demonstrou um pouco da história das falhas de segurança nos consoles da nova geração (Wii, Xbox 360, PS3). E foi interessante ver o modelo de segurança do PS3 e como eles desvendaram as chaves privadas do mesmo, eu só conhecia bem superficialmente o modelo de segurança do Wii. Se você interessa por segurança, consoles e hacking é uma ótima apresentação.


http://www.youtube.com/watch?v=hcbaeKA2moE

[update] - Parece que a chave do PSP estava "dentro" do PS3 agora tanto a cena do PSP e PS3 podem, teoricamente, escrever e rodar código dentro das plataformas da sony.

[update] - Baixe a apresentação do evento. A BBC também noticiou o fato da descoberta do conjunto de chaves que a Sony usa para o PS3 e PSP.

A prática do SEO e os resultados

Apesar de ter um trabalho fixo; hora ou outra também executo trabalhos freelancer java. E ultimamente as propostas de trabalho tem aumentado consideravelmente. E esse aumento se deve (na maioria absoluta) ao uso de um conjunto de técnicas (e ou estratégias) SEO.

É impressionante o quanto o google pode lhe dar retorno com um bom posicionamento, e digo isso baseado apenas no lucro que obtive em pequenos trabalhos ou ajuda (consultória) em Java, Richfaces, JSF, JPA enfim...

Por isso e outros fatores noto que a propaganda paga ao google é um investimento que tem retorno garantido. Só pra esclarecer não tenho nenhum vinculo com google (empregatício porque de uso muito de seus serviços).

Para se ter uma ideia, se você procurar por freelancer java no google, o blog vem em 5º lugar (claro esse posicionamento vai se atualizar) e com esse "5º lugar" noto que a diferença de divulgação por email, forum e etc é extremamente irrisória se comparada ao jeito google de ser.

Portanto fica aqui a dica se não conhece vale a pena dar uma estudadinha em SEO e suas consequências.

Decisões de design - Herança X Composição

Mesmo que esse assunto pareça já explorado de todas as formas ainda há certas situações que relutamos (pelos menos eu) em usar a herança ao invés da composição.
Invejando descaradamente o conto de cada dia do Phillip . Vou contar de uma experiência que tive. O exemplo clássico é o controlador CRUD (seja seu servelet, managed bean, action form... ) que contém os métodos para uso geral e genérico e alguns ganchos. Vou dar um exemplo bem simples de um Managed Bean CRUD.

public class ManagedBeanCRUD [E,ID]{
private E instancia;
public E getInstancia(){return instancia;}
public Void setInstancia(E entidade){this.instancia = entidade;}

public String salvar(){
preSalvar();
servicoCrud.salvar(getInstancia);
return "navegacaoListar";
}
public void preSalvar(){}
}

E apartir desse MB crio os meus outros CRUDS simples, exemplo telefone:

public class TelefoneMB extends ManagedBeanCRUD [Telefone, Integer] {
@Override
public void preSalvar(){
System.out.println("Oi esse é gancho ...");
}
}

Ótimo, houve reuso por meio da herança mas logo veio as seguintes perguntas: porque não transformou os métodos preXXX em métodos abstratos? Porque daí eu teria que obrigar o usuário a implementar sempre mesmo quando não fosse necessário. porque não usou composição ao invés da herança? Porque minha visão (xhtml) já está toda padronizada.

[c:campoentrada binding="#{mb.instancia.numero}"/]
[c:botao binding="#{mb.salvar}"/]

Note que o método salvar não existe (ao menos no fonte) na classe TelefoneMB ele é acessado por herança. A primeira tentativa foi substituir a herança por composição por meio de delegação, minha classe TelefoneMB ficaria mais ou menos assim:

public class TelefoneMB{
private ManagedBeanCRUD[Telefone, Integer] delegate;
public String salvar(){
 return delegate.salvar();
}
// + do mesmo
}

Mas será que não pode ser melhorado?!

Claro que sim até agora consegui chegar num patamar assim: os métodos ganchos se transformam no padrão decorator e a herança se torna composição por delegação mas de um modo diferente, fiz o MangedBeanCRUD ser um atributo de leitura :

public class TelefoneMB{
private ManagedBeanCRUD[Telefone, Integer] crud;

public TelefoneMB(){
   crud.addEventoPreSalvar(new Evento(){
            public void executar(){
                System.out.println("antes de salvar...");
            }
   });
}

public ManagedBeanCRUD getCrud(){
   return crud;
}
}

E na view (jsf, xhtml ...) não terei muita mudança será uma navegação a mais na #EL #{telefonemb.crud.salvar} terei que adicionar o crud antes do padrão CRUD de ser.

Com isso tenho um managed bean livre de más práticas, melhorei o sistema de eventos e mais um plus não terei problemas futuros com proxies do JDK ou GLIB2! Mais camadas e indireções sempre foi o caminho conforme post sobre abstrações pra todo lado.

Todo comentário sempre é e será bem-vindo!

ps: só pra deixar claro não sou contra o uso da herança, há casos que você pode usar herança para compor suas entidades e outros n usos. O único cuidado que deve ter é pensar, pensar, pensar e pensar para decidir se é herança ou não.

Wii Hacking ;D

Primeiramente, pra esclarecer...

O que esse post não é?

Um tutorial de como fazer hacking, desbloquear, instalar o homebrew channel...

O que é?

Uma visão geral (BEM resumida) sobre a arquitetura do wii, os processos de hacking atuais; enfim, se trata mais de um post de curiosidade do que um manual. :P (quem quiser isso pode ir no wii players forum ou gbatemp, nesses sites você encontra o melhor e mais atualizado conteúdo sobre wii hacking).

Wii Hacking

É o ato de tentar hackear a máquina nintendo Wii :)

Mas pra que hackear o Wii?

Pra essa pergunta há N-respostas que vão desde um simples desejo de rodar programas feitos por você ou outras pessoas (homebrew - código não assinados) até rodar jogos (seus backups) pelo hd usb externo.

Então como é feito o processo de hacking do Wii?

Como quase todo hacking, baseado nas falhas existentes. Pra melhor entender e explorar o assunto é necessário ter a visão básica de como funciona (bem básico) a pilha de software do Wii.

[Quase sempre vísivel ao usu] - System Menus (4.2U , 3.5K).
[Quase sempre invísivel ao usu] - IOS sistemas internos (IOS 222,36).
[Quase nunca vísivel ao usu] - BOOT0, BOOT1 e BOOT2.

Os Exploits!

O mais famoso (e também antigo, obsoleto, só funciona com system menus até o 3.4...) deles é o que é executado por meio do jogo The Legend of Zelda: Twilight Princess, mas tem o "inconveniente" de que você necessita de ter o jogo (você deveria tê-lo mesmo :P). Se você quiser saber mais sobre esse exploit (criado pelo Team Twiizers) leia Twilight Hack.

Hoje em dia as pessoas utilizam com maior frequência o Bannerbomb que é um processo bem mais seguro, testado e fácil. Você carrega um SDcard com arquivo compatível com seu system menu e o executa pelo ícone do SDcard.

A famosa expressão Brick!

Há, sempre que se fala desse assunto, um risco ao fazer tais operações. A partir do exploit executado você começa o processo de hacking... isso envolve você 'retirar' algumas IOS que podem lhe 'barrar' de algumas operações, substituir algumas IOS por outras cIOS feitas pela comunidade. Sempre que você alterar essas características você corre o risco. Mas hoje o risco mais é de você atualizar o Wii (pela wifi) para uma versão mais nova do system menu (claro que a nintendo sempre corrige esses bugs, ou tenta) e daí você pode sim ter o Wii invalidado pra sempre. (isso não é brincadeira)

E o hacking ... como é feito?

Você executa um dos exploits (por sua conta é total risco, sobre a pena do Bricked Wii) que normalmente lhe dá condições para que o HomeBrew Channel seja instalado. Esse será sua porta pra rodar aplicativos feitos por você ou outras pessoas na Internet. Além do homebrew channel é importante também remover alguns IOS e substituir outros por cIOS. Isso é feito pra que você volte a ter 'bugs' conhecidos e também acesso a dispositivos externos como HD USB. Um fato importante e muito bom de se 'hacker' o wii, é que você pode fazer várias operações que garantem uma vida útil maior e também ferramentas pra recuperação de erros. Backup da NAND pode lhe garantir num futuro uma possível 'restauração' do sistema.

Ferramentas que normalmente são instaladas

HomeBrew Channel - também conhecido como HBC, é o canal (aparece no menu inicial do Wii) que lhe permite executar aplicativos não assinalados.
BootMii - Um conjunto de sistemas que você pode instalar no wii pra lhe oferecer mais 'utilidades' ao aparelho.
Priiloader - Sistema que fica exatamente entre a sequência de boot e o system menu. Hoje em dia ele é instalado como se fosse um IOS. Ele lhe dá acesso à vários hacks interessantes e úteis, por exemplo: remover a atualização automática, apertar A naquela tela chata de inicio... e claro pode ser sua salvação, caso o venha a Brickar, ele fornece meios pra você recuperar sua NAND (baseado no seu bkp). Mas ele como IOS não garante 100% de unbrickablility. (Perfeito é quando você consegue, em versões mais antigas do Wii, instala-lo as boot2 aí sim você tem um Wii quase unbrickable, já que você detém o poder do boot :) )
Multiple WAD Manager - O famoso MMM é um gerenciador de pacotes de instalação para o Wii ele é essencial. É díficil de usar, a principio, pois sua interface (textual, não gráfica) não ajuda muito. Nele que você instala cIOS (custom IOS), remove IOS, instalar canais...

ps: mais uma vez, não mude seu wii sem conhecer o que é feito com ele e sem ter a noção dos riscos ao substiuir IOS's por cIOS's. E claro, sempre assuma os riscos por sua conta. (ps2: eu, depois de me informar, acho seguro e com possibilidades pequenas [mas ainda existem] de você perder seus wii.)

E lembre-se há homebrews que valem muito a pena.

Habilitando Cache level 2 no JPA 1.0 (Hibernate)

Uma das características prometidas para o JPA 2.0 e já implementada no hibernate é Second Level cache! Pra habilita-lo é bem simples:

Basta informar ao Hibernate (seja pelo persistence.xml ou pelo applicationContext.xml) as seguintes propriedades.
hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider {classe padrão pra prover serviços de cache}
hibernate.cache.use_query_cache=true {se deve ou não fazer caches de queries}

Lembrando que por padrão você deve configurar entidade a entidade as quais devem ou não serem cacheadas (com a anotação @Cache junto a @Entity, você também pode cachear coleções!) e qual a política (de concorrência) que deve ser usada no esquema de cache (NONSTRICT_READ_WRITE, NONE, READ_ONLY, WRITE_ONLY, TRANSACTIONAL). Depois é só observar pelo log de sql :D! Have fun!

NoSuchFieldException no Hibernate (JPA)

No padrão JPA você pode anotar suas entidades pelos métodos (getters) ou pelos atributos, é um ou exclusivo ou vocÊ anota tudo pelos atributos ou pelos getters. O relato que segue é sobre um código que funcionou muito bem por muito tempo mas que na última sexta feira (28/05/2010) me deu muita dor de cabeça.

Devido a limitação do JSF (1.X) quanto a população de combos (o usuário do framework é obrigado a passar uma lista/matriz de SelectItem), eu criei um código para que dado uma lista de objetos, o nome do atributo à ser mostrado (descricao) e o nome do atributo com valor (id) retorna uma matriz de SelectItem.

API SelectItem[] converterListaParaCombo(final List objetos,String attMostrar,String attValor)

O código é simples; faz um loop nos objetos e vai recuperando os valores dos campos por reflexão e criando objetos do tipo SelectItem e os adicionando na lista/matriz.

Bem, voltando ao relato. Quase sempre eu usei anotar (JPA Annotations) as entidades nos campos, por boa prática comecei anotar pelos getters.

Quando fui testar percebi que o método converterListaParaCombo estava lançando a exceção NoSuchFieldException. Dessa vez o log não ajudou quase nada, tive que debugar... para minha surpressa a lista ia sendo populada normalmente até chegar num objeto (da lista) que não tinha o campo descrição :S. A primeira pergunta: Como isso é possível se eu mesmo declarei o campo na entidade?

Para responder essa pergunta criei mais um teste sobre a lista de objetos que eu passava para o método. Mandei (imperativamente) um sysout sobre getId e getDescrição... aqui outra surpresa não houve nenhum erro :S. Numa pesquisa mais profunda sobre o assunto descobri que o hibernate tem "seu modo de fazer cache" que pode causar alguma surpresa para os mais desavisados e na verdade ele nem sempre retorna a sua entidade e sim um proxy {eu pensava
que esse proxy era somente para List}. E um desses proxies "não tinha" o campo descricao...

Para resolver o problema, eu apenas mudei no método a forma de recuperar os valores. Ao invés
de pegá-los pelo atributos agora pelo pelos métodos getters. :D

Adicionando escopo de conversação ao JavaServer Faces 1.X (JSF 1.2)

Que o JSF não é perfeito todos sabemos mas se há algo que me incomoda muito são duas coisas chatas: URL amigáveis (que consegui resolver facilmente com PrettyFaces.) e tratar tudo como escopo de sessão (por falta de um escopo entre o requisição e o sessão).

Para o último problema começei a pesquisar algumas soluções possíveis e cheguei ao framework MyFaces Orchestra.

O MyFaces Orchestra é um framework que pode ser usado em aplicações web para prover as caracteristicas de escopo conversacional. Apesar de ter sido criado para ser um framework de escopo para web presentations ele tem, hoje, só implementações para JSF 1.1, 1.2 e 2.0.

Para utilizar o framework você precisa, obrigatoriamente, usar o Spring 2.0 (ou maior) como gerenciador de seus managed beans. E claro ter os modulos do Orchestra (core12 e o core15 são os usados no exemplo) no seu classpath.

Exemplo

Fiz um exemplo utilizando Eclipse juntamente com quarteto fantástico : richfaces 3.3.3 + Facelets + spring 3.0.1 + hibernate 3.0.2 (JPA)! e tive que mudar/configurar os seguintes arquivos:

web.xml

 <listener>
  <listener-class>org.apache.myfaces.orchestra.conversation.servlet.ConversationManagerSessionListener</listener-class>
 </listener>

applicationContext.xml

    <import resource="classpath*:/META-INF/spring-orchestra-init.xml" />
       
    <bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">
      <property name="scopes">
        <map>
          <entry key="conversation.manual">
            <bean class="org.apache.myfaces.orchestra.conversation.spring.SpringConversationScope">
              <property name="timeout" value="30" />
              <property name="lifetime" value="manual"/>
            </bean>
          </entry>

          <entry key="conversation.access">
            <bean class="org.apache.myfaces.orchestra.conversation.spring.SpringConversationScope">
              <property name="timeout" value="30" />
              <property name="lifetime" value="access"/>
            </bean>
          </entry>
        </map>
      </property>
    </bean>

Simplesmente após ter feito tais mudanças e ter atendido aos requisitos básicos: declarei meu bean no applicationContext com scope="conversation.access". No exemplo naveguei de uma página listar.xhtml para outra editar.xhtml mantendo o estado! Fiz testes posteriores também com uso de Ajax (a4j) com multiplos requests para mesma página ou outra tudo passou perfeito!

Se quiser ver o projeto baixe aqui o projeto (.war com sources)!

Further Reading!

O framework também fornece uma solução (essa eu não testei) para os lazy initializations lançados (esse com integração forte ao hibernate). Há também um esquema de binding muito legal.

ps: todo o post está levando em consideração as características do Jsf 1.x o Jsf 2.0 resolve alguns desses empecilhos.
ps2: ainda há algo que me incomoda é a quantidade de linhas no faces-config para lhe dar com navegação entre as páginas.
ps3: fiz testes básicos nesse projeto aconselho fazer mais testes reais na sua aplicação antes de substituir session por conversation.

Integrando google app engine (GAE) + Spring 3.0.2 + Hibernate (JPA)

Introdução

Usar a infraestrutura do google para hospedar suas aplicações pode parecer algo fantástico. Imagine ter todo o poder e segurança fornecido pelo Google diretamente nas suas aplicações. É com essa promessa que o Google App Engine (GAE) foi lançado. Pode-se criar aplicações Web usando Python ou Java.
+Vantagens: boa documentação em pt_BR, aproveitar da escalabilidade do google, desenvolver em Java (no ponto de vista de número de pessoas aptas) e etc.
-Desvantagens: JRE com menos classes, frameworks não funcionando ou funcionando parcialmente, restrições ao uso do JPA e etc.

Configurando plugin no Eclipse

Para facilitar, muito, a criação, deploy e debug de seus aplicativos aconselho a utilizar o Eclipse juntamente com o plugin fornecido pelo google.

Integrações

Spring 3.0.2

Gosto de usar o controle transacional do Spring (@Transactional) , injeção de dependência e a implementação do open session in view (OpenEntityManagerInView) e para usar tais recursos tive que configurar o web.xml dessa forma.

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<listener>
<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
</listener>

<filter>
<filter-name>SpringOpenEntityManagerInViewFilter</filter-name>
<filter-class>org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>SpringOpenEntityManagerInViewFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

Já o arquivo applicationContext.xml ficou assim.

<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean" lazy-init="true">
<property name="persistenceUnitName" value="t3st3" />
</bean>
<bean name="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<tx:annotation-driven transaction-manager="txManager" />

JavaServer Faces 2 (JSF 2.0)

Costumo repassar o trabalho de cuidar do ciclo de vida dos managedbean para o Spring. A utilização do jsf 2 (implementação myfaces) traz as novidades do jsf 2.0 (que é um grande passo) e saber que é compatível com gae é muito bom. Bem meu web.xml ficou assim.

<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>*.jsf</url-pattern>
</servlet-mapping>


<!--
We need to set annotation lifecycyle provider manually as org.apache.myfaces.config.annotation.NoInjectionAnnotationLifecycleProvider.
Other providers use some classes that are restricted on Google App Engine.
-->
<context-param>
<param-name>org.apache.myfaces.config.annotation.LifecycleProvider</param-name>
<param-value>org.apache.myfaces.config.annotation.NoInjectionAnnotationLifecycleProvider</param-value>
</context-param>

<!--
Need to set a secret to avoid javax.crypto.BadPaddingException.
"param-value" must be Base64 encoded.
More details: http://wiki.apache.org/myfaces/Secure_Your_Application
-->
<context-param>
<param-name>org.apache.myfaces.SECRET</param-name>
<param-value>NzY1NDMyMTA=</param-value>
</context-param>

e o faces-config.xml assim:

<application>
<variable-resolver>org.springframework.web.jsf.DelegatingVariableResolver</variable-resolver>
</application>

Hibernate

Só usar! Ahh é mesmo tem que se criar um arquivo persistence.xml (META-INF) mínimo.

Observações gerais:
Tente usar sempre o objeto Key como id, pois objetos filhos devem usar Key ou String codificada, não sendo possível usar long ou int.
Você pode acompanhar o status do ambiente, quais serviços estão online qual a latência de uso e etc.

Artigo publicado na InfoQ Gringa

Nota rápida: o pessoal da InfoQ publicou meu artigo sobre Implementing Google's "Did you mean" Feature In Java. Todo feedback será bem-vindo.

URL amigáveis com JavaServer Faces (jsf) 1.X

Uma das críticas dos usuários de JSF é : "você não consegue criar urls que podem ser bookmarked (favoritadas)".

Eu pensei que iria ter uma trabalheira do cão... pensei que não iria dar muito certo com Richfaces, Spring ... enfim todas as integrações... pensei... pensei errado! :)

Há um framework chamado PrettyFaces (para jsf 1.1 , 1.x e 2.0) o qual o uso é extremamente fácil.

Com apenas dois passos você adiciona url amigáveis ao JSF:

1º Passo: Registrar o filtro no web.xml

<filter>
<filter-name>Pretty Filter</filter-name>
<filter-class>com.ocpsoft.pretty.PrettyFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>Pretty Filter</filter-name>
<url-pattern>/*</url-pattern>
<dispatcher>REQUEST</dispatcher>
<dispatcher>FORWARD</dispatcher>
<dispatcher>ERROR</dispatcher>
</filter-mapping>

2º Passo: criar o arquivo pretty-config.xml dentro de WEB-INF:

<pretty-config
xmlns="http://ocpsoft.com/prettyfaces-xsd"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://ocpsoft.com/prettyfaces-xsd
http://ocpsoft.com/xml/ns/prettyfaces/pretty-1.0.xsd">
<url-mapping id="verNoticia">
<pattern>/noticia/#{myBean.currentStoryId}/</pattern>
<view-id>/noticia.xhtml</view-id>
<action>#{myBean.loadComment}</action>
</url-mapping>
</pretty-config>

Com as configurações acima se você digitasse http://seuhost/seuprojeto/noticia/12345/ você mostraria o bean (de ViewID=/noticia.xhtml) com a notícia de id=12345 :)

ps: um passo omitido seria o download do jar e o registro do mesmo no classpath da sua aplicação.

Freelancer Java - Tive bons resultados.

Freelancer Java

De acordo com a Wikipedia: "Freelancer é o termo inglês para denominar o profissional autônomo, que se auto-emprega em diferentes empresas ou, ainda, guia seus trabalhos por projetos, captando e atendendo seus clientes de forma independente. É uma tendência muito em voga no mercado de jornalismo, design, propaganda, web, tecnologia da informação, música e muitos outros."
Há - muito - tempo atrás li um post interessantíssimo denominado o guia de guerra para freelancers. E eu também tentei me aventurar pelo mundo dos serviços de freelancer java. Até que me posicione bem no google, se você pesquisar "trabalho freelancer java" no google, meu blog aparecerá no fim da primeira página ou no inicio da segunda, claro (quase) todos os créditos aos trabalhos que obtive foram vindos do google. Para minha surpresa tive alguns contatos bem rápidos e um ponto interessante foi que a maioria deles não moravam próximo a mim. Todo trabalho desenvolvido (para os clientes) foi baseado na confiança e a comunicação basicamente foi por emails. Dá pra ganhar uma graninha extra com disciplina e responsabilidade. =D

boasPraticas.add deploy, tdd, ddd

Recebi a visita de um super amigo das antigas (leia-se VB.NET), eu tinha que entegrar um simples gerenciador de conteúdo e meu amigo me acompanhou e ficou questionando sobre por que eu fazia assim, usava aquilo, não fazia isso... no fim ele disse que precisava de desenvolver com mais qualidade, controle e facilidade. Ele ainda me pediu uma lista de livros pra ler e quais praticas eu usava, naquele momento começei a falar tanta coisa, ferramenta, framework, metodo... que ele mesmo disse "escreva uma lista dessas boas práticas"! E aqui estou eu, vou tentar apenas listar os tópicos e os links que acho interessante.

Não reivente a roda - quase sempre há uma common pronta, então quando surgir uma necessidade pesquise antes sobre o assunto. Tive uma péssima experiência com um agendador de tarefas (que eu criei) em Java, tudo isso porque não conhecia o Quartz.
Melhore seu design OO - por mais que pareça esgotado esse assunto, ainda há pessoas que não compreendaram assuntos básicos, esse tópico (sobre OO) não dá pra ser resolvido com uns poucos links mas se eu pudesse indicar um site seria o do Philip Calçado. PS: outras boas práticas abaixo listadas podem lhe ajudar também num design mais charmoso.
TDD - uma ótima prática que pode lhe livrar de dores de cabeças infernais. No inicio pode parecer perda de tempo mas com tempo você vai ver o valor de usar Test Driven Development.
Logging - não há nada mais chato do que ler grandes arquivos de logging não é mesmo?! Há sim, debugar! :P então: prefira Logar do que Degubar! Pode começar lendo um tutorial de log4j.
Deploy - Automatizar suas construções e criar um processo de deploy continuo :)
Boas práticas com JPA - às vezes passamos raiva só por desconhecimento (profundo) de um certo recurso do framework. Logo digo leia esse ótimo post sobre os bons habitos de usar JPA.
Integração continua - Leia o post de Integração continua ahhh outra dica automatize tudo o possível.
Aprenda outra linguagem - Sua cabeça pode se tornar viciada numa linguagem só e isso pode lhe privar de conhecer ou melhor entender como outros organismos funcionam. Além do mais é divertido aprender Ruby e ver como as pessoas resolvem problemas de maneiras tão distintas.
Comunidade - Nem só de código fonte a comunidade open-source se alimenta, usar forums para aprender e ensinar é algo muito valioso.
Outros bons livros :)

Tudo isso pode parecer plágio de um grande blog de ótimo desenvolvedores, mas não é :) Juro!

Como usar JavaScript na plataforma Java

Em minha mente o assunto scripting na plataforma Java já estava bem explorado e difundido. Mas hoje fui supreendido por um amigo com um mini-framework que servia de analisador e parser para simples fórmulas matemáticas como p.ex:
2+2-1*3/3
(2+2)*10

Usando Java 6 basta esse simples código.

      ScriptEngineManager factory = new ScriptEngineManager();
      ScriptEngine engine = factory.getEngineByName("JavaScript");
      try {
          String script = " 10 + 2 * 2 "; //ou sua expressão
          Object result = engine.eval(script);
          System.out.println(result);
      } catch (ScriptException ex) {
          System.out.println("deu erro :P "+ex);
      }

JTableAnnotations - Um jeito mais simples de criar JTable

JTableAnnotations

Há algum tempo atrás escrevi um mini-framework para criação de JTable por anotação. Talvez esse pedaço de código possa lhe servir, criar JTable sempre é uma tarefa chata e tediosa (e para alguns dificil). O JTableAnnotations propõe uma simplificação no processo de configuração e preenchimento das tabelas.

Basicamente você precisará anotar suas entidades

@JTableConfiguration(rowHeight=48)
public class Product {
@JTableColumnConfiguration(order=1,width=55)
private Long id;
@JTableColumnConfiguration(order=2,width=300,editable=true,align=Align.CENTER)
private String name;
@JTableColumnConfiguration(order=3,name="Price",decimalFormat="U$ 0.00")
private BigDecimal value;
@JTableColumnConfiguration(order=4,name="Costumer Name",width=300)
private Customer customer;
@JTableColumnConfiguration(order=0,name="Photo",cellRender=IconCellRender.class)
private String picturePath;

E então o trabalho de configurar e popular fica a cargo da classe Configurator:

Customer master = new Customer();
master.setName("Master");
master.setUserName("Admin");
list = new ArrayList();
list.add(
createProduct(
master, 0L,
"Nintendo Wii",
"pictures/wii.jpg",
new BigDecimal(999.50)));
list.add(
createProduct(
master, 1L,
"XBox360",
"pictures/xbox360.jpg",
new BigDecimal(1020.85)));
list.add(
createProduct(
master, 2L,
"PS3",
"pictures/ps3.jpg",
new BigDecimal(1000.0)));
list.add(
createProduct(
master, 3L,
"PSP",
"pictures/psp.jpg",
new BigDecimal(490.0)));
list.add(
createProduct(
master, 4L,
"Nintendo DS",
"pictures/nds.jpg",
new BigDecimal(359.59015)));
new Configurator().configureAndPopulateJTable(jTable, list);

E voilá!
(odeio essa resolução do blogspot)
[Clique aqui para ver a figura abaixo]

Mais informações na página do projeto http://code.google.com/p/jtableannotations/

Vagas Agile Funny - OFF

Com o título Vagas na Fibonacci Soluções Agéis - foi um anuncio feito pelo GOJava (legal) veja:

Requisitos:

Imprescindíveis:

- Gostar muito de programação
- Não achar que a carreira ideal é aquela em que você começa como programador, é "promovido" para analista e um dia se torna gerente de "sua própria equipe"
- Preferir trabalhar em uma equipe auto-gerenciável
- Não acreditar que uma única tecnologia é a solução para todos os problemas, mas sim que existe a ferramenta correta para cada trabalho
- Ser bom em google-fu

Desejáveis

- Experiência/conhecimento em Desenvolvimento Orientado a Testes, Desenvolvimento para Web, Arquitetura de Software, Desenvolvimento Orientado a Objetos, Metodologias Ágeis
- Saber jogar truco
- Ser ala-direita ou centro-avante no futebol (precisamos completar o time)
- Gostar de video-game

Benefícios:

- Os tradicionais vale-transporte e plano de saúde
- Uma cozinha com lanche disponível o tempo todo e dois horários de lanche por dia (de manhã e de tarde)
- Não ter chefe, porque aqui não é nenhuma tribo.
- Você nunca vai ter que explicar seu trabalho nem vai ser avaliado com base em um Diagrama de Gantt

Quem derá as empresas tivessem um pouco mais desse espírito.
PS: não trabalho, não conheço nada nem ninguém da empresa.

Jpcsp - v0.4 lançado - Castelvania Dracula X Chronicles

JPCSP - O emulador do PSP feito em Java

A muito tempo não dou mais nenhuma contribuição no projeto Jpcsp mas não deixo de acompanhar o progresso do projeto. (Pra quem não sabe o que é o Jpcsp!) A última notícia foi mesmo um presente de natal, a versão 0.4 do Jpcsp foi lançada e já está disponível para download.

Sinto um pouco de orgulho por ter conseguido participar, efetivamente, e realizar um dos meus sonhos de moleque. (Criar um emulador :) )... agora deixando de conversa fiada segue alguns screenshots!

Castlevania - Dracula X Chronicles

Heatseeker

God of war (In menu)

Feliz Natal! ho ho ho - Veja mais notícias do Jpcsp ou os meus posts antigos sobre Jpcsp.

Adicione o recurso "você quis dizer" nas suas aplicações Java

SpellChecker - Uma extensão no Lucene

Continuando brincando com Lucene, no novo Lucene 3.0.0 encontrei uma pasta contrib na qual há libs diversas. Uma delas é o SpellChecker que lhe oferece recursos para que você implemente em suas aplicações java (web ou desktop) recursos como "Você quis dizer".

Recurso Você quis dizer

Imagine : Você é dono de uma loja virtual na qual é oferecido DVDs para venda. Um fanático pelo ator Arnold Schwarzenegger entra no sua loja e tem em mente comprar todos os DVDs desse ator (hoje, governador) a primeira ação do usuário é digitar o nome do ator no campo busca. Facilmente ele irá errar a digitação do nome, por exemplo digitando "arnold swuazeneger", e isso não deveria ser algo impeditivo para compra dos DVDs. Para esse problema bastaria a solução do tipo "Você quis dizer foo" implementada pelo Google Inc. no seu motor de busca. Você consegue esse mesmo, ou próximo, efeito em suas buscas utilizando uma das extensões do Lucene, chamada de SpellChecker. O exemplo-código abaixo é simples e demonstra como fazer isso.

Código

     Directory diretorioDicionario = new RAMDirectory();
    //criação do diretório
     SpellChecker sp = new SpellChecker(diretorioDicionario);
    //instânciação do objeto SpellChecker
     sp.indexDictionary(new PlainTextDictionary(new File("dicionario.txt")));
    //indexação do Dictionary (há duas implementações).
     String pesquisa = "arnold swuazeneger";
    //seu termo pesquiado
     int numeroDeSugestoes = 5;
    //número de sugestões similares
     String[] similares = sp.suggestSimilar(pesquisa, numeroDeSugestoes);
    //as sugestões em si.

     System.out.println("Seu Termo : " + pesquisa);
       for (String palavra : similares) {
           System.out.println("Você quis dizer: " + palavra);
       }

     pesquisa = "bava";
     similares = sp.suggestSimilar(pesquisa, numeroDeSugestoes);
     System.out.println("Seu Termo : " + pesquisa);
       for (String palavra : similares) {
           System.out.println("Você quis dizer: " + palavra);
       }

Saída

---

Seu Termo : arnold swuazeneger
Você quis dizer: arnold schwarzenegger

---

Seu Termo : bava
Você quis dizer: java
Você quis dizer: lava
Você quis dizer: bala

---

Arquivo dicionario.txt:

arnold schwarzenegger
jean claude van damme
java
lava
bala

Conclusão

Nem sempre é tão difícil quanto parece, sempre há uma roda já pronta para seu problema. Você ainda pode ajustar a acurácia da pesquisa pelo método setAccuracy do SpellChecker. Claro que o uso do recurso em produção requer mais e mais atenção quanto ao diretório e o dicionário de busca. Baseado nos códigos acima, facilmente você consegue levar essa características para seus sistemas Java Web ( JSF - JavaServer Faces, Struts, JSP).