A arte de desenvolver, entender e manter sistemas

Novo blog - www.leandromoreira.com.br

2011-04-20T14:21:00.000-07:00

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

2011-04-07T19:44:00.000-07:00

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

2011-03-16T06:17:00.001-07:00

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...

2011-01-04T03:51:00.000-08:00

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

2010-11-04T05:30:00.000-07:00

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

2010-08-10T12:10:00.000-07:00

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

2010-07-13T05:12:00.000-07:00

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)

2010-06-29T11:23:00.000-07:00

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)

2010-05-29T18:32:00.000-07:00

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)

2010-05-07T07:48:00.000-07:00

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)

2010-04-28T07:25:00.000-07:00

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>


<context-param>
<param-name>org.apache.myfaces.config.annotation.LifecycleProvider</param-name>
<param-value>org.apache.myfaces.config.annotation.NoInjectionAnnotationLifecycleProvider</param-value>
</context-param>


<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

2010-04-09T07:03:00.000-07:00

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

2010-04-09T04:19:00.000-07:00

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.

2010-03-29T12:17:00.000-07:00

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

2010-03-09T05:54:00.000-08:00

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

2010-02-23T04:59:00.000-08:00

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

2010-02-13T17:30:00.000-08:00

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

2010-01-27T04:22:00.000-08:00

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

2009-12-23T03:37:00.000-08:00

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

2009-12-03T04:28:00.000-08:00

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).

Tutorial Apache Lucene 3.0.0 - motor de busca textual

2009-12-01T08:42:00.000-08:00

Lucene um motor de busca textual

No dia 25 de novembro foi lançado a nova versão do motor de busca Lucene, a versão 3.0.0. Lucene é um framework de alta performance para busca textual feito em java. (há versões para php e .net também) Uma das características marcantes dele é a integração com Hadoop. (um framework para computação distribuida - que possui, dentre outros, um MapReduce e um sistema de arquivos distribuido HDFS)

Porque usar Lucene?

Imagine o seguinte cenário: Seu usuário deseja criar um modulo de gerenciamento de artigos e também expó-los na Internet. As informações do artigo são: título, autor e o contéudo. Normalmente cada artigo desse contém cerca de 1500 palavras e o usuário poderá buscar pelo conteudo desses artigos. Suponha que há 1 milhão e meio de artigos para serem cadastrados, o simples uso de um banco de dados e o operador LIKE '%palavra%' é inviável. E aí que entra um bom framework de busca textual, usá-lo passa ser a solução mais tranquila e viável. Além de trazer velocidade, também traz outras características nas buscas que dificilmente fariamos codificando tudo do zero.

Domain-Specific Language | Ubiquitous Language

Há vários termos usados na terminologia do framework, os principais são: Documento, Campo, Diretório, Indexador, Pesquisador, Analisador e Termo.

Documento - é o conjunto de dados que você deseja indexar, por ex. título, conteudo e autor formam o documento artigo, pode ser visto como um objeto no lucene é visto como Document.
Campo - é o dado, identificado, que pode ser analogo a um campo de uma tabela ou uma propriedade de um objeto no lucene é visto como Field.
Diretório - conceito abstrato que denota um local para guardar os índices no lucene é visto como uma interface Directory, que possui diversas implementações DbDirectory, FSDirectory, JEDirectory, RAMDirectory.
Indexador - é o responsável por indexar os documentos num diretorio no lucene é visto, geralmente, como IndexWriter.
Pesquisador - responsável por pesquisar uma Query no diretorio de índices, no lucene é visto como Searcher.
Analisador - atua como um filtro e faz uma pré-avaliação do que pode ser indexado ou não, no lucene há uma lista de vários analisadores.
Termo - pode ser visto como objeto que pode ser usado como parametro da pesquisa, composto pelo nome do campo e o valor a ser pesquisado, no lucene é visto como Term.

Como isso funciona?

A descrição a seguir é um resumo bem simplificado sobre o funcionamento de um motor de busca textual. A primeira fase, geralmente, é a indexação do documento, nessa fase o documento é analizado (por um Analizer que também já retira as stopwords) para posteriomente ser indexado.


Set stopWords = new HashSet();
stopWords.add("the");
stopWords.add("it");
stopWords.add("is");
IndexWriter writer = new IndexWriter(FSDirectory.open(INDEX_DIR),
  new StandardAnalyzer(Version.LUCENE_CURRENT,
                                    stopWords),
  false,
  IndexWriter.MaxFieldLength.LIMITED);

No Lucene você pode criar um índice usando o IndexWriter, a criação desse objeto envolve dizer onde será (ou está) o diretório dos índices, qual analizador você irá utilizar, se irá criar o indice e qual a quantidade máxima de campos.

O objetivo do indexador é indexar documentos, para tanto é necessário que haja documentos para serem indexados.

Document doc = new Document();
doc.add(new Field("nomedocampo", "valores a serem guardados", Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.add(new Field("camp1","valores a serem analisados tokenizados",Field.Store.YES, Field.Index.toIndex(true, true)));
writer.addDocument(doc);

É o objetivo final de todo processo de busca textual é mesmo a busca em si.

String valueToBeSearched = "red";
String index = "indexDir"; //dirotorio base do indice
IndexReader reader = IndexReader.open(FSDirectory.open(new File(index)), true); //indexador
Searcher searcher = new IndexSearcher(reader); //pesquisador
QueryParser parser = new QueryParser(Version.LUCENE_CURRENT, field, analyzer); //transoformador do texto em uma query
Query query = parser.parse(valueToBeSearched); //a consulta (query) em si
TopScoreDocCollector collector = TopScoreDocCollector.create(hitsPerPage, false); //os melhores resultados
searcher.search(query, collector);
ScoreDoc[] hits = collector.topDocs().scoreDocs; //o conjunto de melhores documentos para a consulta

int maximo = hits.length;
Document doc = searcher.doc(hits[index].doc);
String valor = doc.get("nomeDoCampo");

Recursos na busca de documentos

Quando se faz uma pesquisa por documentos no Lucene podemos utilizar de alguns operadores (+, -, AND, NOT, OR, * e etc.) juntamente com o termo pesquisado ou apenas pesquisar uma frase completa.

Exemplo : termo
Consequência: Irá pesquisar a palavra "termo" nos documentos indexados.

Exemplo : termo OR palavra ( == termo palavra)
Consequência: Irá pesquisar "termo" ou "palavra" nos documentos indexados.

Exemplo : +termo +palavra ( == termo AND palavra)
Consequência: Irá pesquisar "termo" e "palavra" nos documentos indexados.

Exemplo : campo:termo
Consequência: Irá pesquisar "termo" no campo "campo" nos documentos indexados.

Exemplo : +homer +simpsons -house
Consequência: Irá pesquisar documentos que contenham homer e simpsons e não tenha house.

Exemplo : "termo exato"
Consequência: Irá pesquisar documentos que contenham exatamente "termo exato".

Exemplo : java*
Consequência: Irá pesquisar documentos que contenham palavras que começem com java (javadb, javanet...).

Exemplo : java~
Consequência: Irá pesquisar documentos que contenham palavras similares a java como por ex. lava, jaba...

Finalizando tive as seguintes impressões sobre essa nova versão do Lucene.

Prós:

Maior facilidade para uso do framework, ex: criações de Fields estão bem mais fluentes.
Sensível otimização nos tempos de busca e indexação.

Contras:

Otimas ferramentas como luke ainda não tem suporte para a versão 3.0.0. (mas já há uma solicitação aberta para tal mudança.)
Muitas mudanças no core do framework; o que fez livros mais antigos quase perderem seu valor.

Referências

Ótimos slides sobre Domain Specific Language (DSL) interna

2009-11-24T02:24:00.000-08:00

Esse é apenas um encaminhamento para o ótimo post sobre dsl interna e tecnicas para construção da mesma.
http://blog.brianguthrie.com/articles/2009/11/23/slides-for-my-talk-on-construction-techniques-for-internal-dsls para acessar diretamente o link dos slides clique aqui.

JPA - lock otimista e pessimista, concorrência e afins

2009-10-29T06:31:00.000-07:00

JPA - Java Persistence API

JPA é especificação para mapeamento ORM e persistência de dados inspiradíssima no famoso framework Hibernate.

A especificação JPA (1.0) já é amplamente usada e aceita na comunidade de desenvolvedores Java. Há vários provedores de implementação para o padrão ( Hibernate , EclipseLink, TopLink ...)

Um assunto pouco explorado, quando se trata de tutoriais de jpa, é sobre locks (otimista e pessimista). E é sobre esse assunto que tento escrever um pouco aqui.

Tratamento de concorrência em bancos de dados

Há basicamente três tipos de tratamento para concorrência em banco de dados:

Otimista - Quando é criado mecanismos para versionar o dado, no momento em que o banco vai efetivar sua operação sua versão é checada para garantir que você está com um dado que não foi alterado.
Pessimista - O banco simplesmente trava o dado e só aquele que tem a trava consegue trabalhar com os dados.
Ostrich - Quando não há tratamento nenhum pra concorrência :) , ou seja, a maioria dos casos atuais.

O exemplo básico

Começaremos com os perigos do modo Ostrich de agir. Para exemplificar criaremos uma simples classe.

@Entity
public class Produto implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String nome;
private double quantidade;
//getters and setters omitidos
}

Agora considere dois usuários A e B trabalhando sobre o Produto com id = 1( Nintendo Wii) ambos usuários têm o mesmo produto na tela de edição, o usuário A modifica quantidade e salva antes do usuário B, já o usuário B modifica o nome e salva depois. Note que há incosistência, o usuário A acredita (porque ele editou e salvou) que alterou a quantidade de nintendos wii, porém o usuario B (ainda com a quantidade antiga) mudou o nome e salvou o objeto. O que acontece? Depende do seu provedor de JPA, há casos em que o update só é feito para a coluna modificada mas há casos em que o objeto todo é modificado, o que causa claramente inconsistência. Escrever, escrever e escrever pode não ajudar então veja o código abaixo exemplificando esse cenário.

            Produto nintendoWiiA = em.find(Produto.class,1L);
            Produto nintendoWiiB = em.find(Produto.class,1L);
            /*Usuário A*/
            em.getTransaction().begin();
            nintendoWiiA.setQuantidade(45.0D);
            em.getTransaction().commit();

            /*Usuário B*/
            em.getTransaction().begin();
            nintendoWiiB.setNome("Nintendo WII");
            em.getTransaction().commit();

            System.out.println(em.find(Produto.class,1L));

ps: O código é apenas para demonstrar como isso é feito, não é funcional.

Agora para mudar esse exemplo para o modo otimista de ser basta criarmos uma propriedade no objeto com a anotação @Version para denotar que este campo será usado para o fim da implementação otimista. Esse campo deve ser int, long ou timestamp.

Com a adição do lock otimista quando o usuário B fosse tentar salvar suas modificações ele receberia a execeção OptimisticLockException. Isso já garantiria ao menos a notificação ao usuário que alguém estava trabalhando sobre o mesmo dado e ( lembra das canseiras que o IDE nos livra no versionamento de código) apartir dai você poderia mostrar o que foi mudado para o usuário tomar a decisão de salvar ou não suas alterações.

A parte chocante fica por conta do modo pessimista de ser, a JPA 1.0 não suporta diretamente o modo pessimista de ser (O JPA 2.0 prevê esse modo a mais :)

Então o que fazer?

Imaginem duas contas bancárias: (sempre esse exemplo) aMinhaConta (com saldo de R$ 150,00) e a suaConta (com saldo de R$ 25.000,00) e você quer me presentear com um Wii mas não tem como mandá-lo pelo correio, logo acha mais conviniente realizar uma transferência para que eu compre. O processo (bem simplificado) se resume a isso:

#0 quantiaASerDoada = R$ 1390,00;
#1 se suaConta.saldo > quantiaASerDoada então
#2 suaConta.transerePara(minhaConta, quantiaASerDoada);
#3 fim se

Se entre a linha 1 e 2 você fizer um saque de R$ 25.000,00 (isso pode ocorrer) a transferência não deveria ser realizada. Um modo para que isso ocorra é travar (lock) o dado que pode sofrer com essas concorrências. No JPA 1.0 você pode travar um objeto em dois passos (ai reside el peligro).

#0 Conta suaConta = em.find(Conta.class, 175789);
#1 em.lock(suaConta,LockMode.Write);

Mais uma vez entre a linha 0 e a 1 pode ocorrer um problema de concorrência. (tanto que a especificação JPA 2.0 já prêve um modo similar ao session do hibernate, o travamento no momento da leitura, em.find(Conta.class, 175789, LockMode.PESSIMISTIC);)

Solução fácil para o problema acima

Basta (se estiver usando Hibernate as your JPA provider) :

((Session) ((EntityManagerImpl) em.getDelegate()).getSession())

O session já tem um jeito de select for update session.get(SuaClasse.class, seuId, tipoDeTravamento). ( já perceberam que pra cada problema que você encontra na JPA 1.0 o hibernate quase sempre tem a solução?!)

Referências

http://en.wikibooks.org/wiki/Java_Persistence/Locking
http://www.javaworld.com/jw-07-2001/jw-0713-optimism.html

Organizacao é tudo

2009-10-22T06:48:00.000-07:00

Para as pessoas que moram no Rio de Janeiro ou que tenham disponibilidade para verem o evento Caelum Day | in Rio já bastaria dizer que o evento será no mínimo bom. Mas dessa notícia o que gostaria de destacar não é só o evento ( se puder ir, vá :) ) e sim a organização do site do evento... algo que deveria ser copiado, isso mesmo ctrl+c ctrl+v! Vejam o site do evento Caelum Day, ele possui as características padrões como : Programação do Evento , grandes nomes para palestrar (Philip Calçado), inscrições e etc. porém dentro dessas características comuns ele traz informações IMPORTANTÍSSIMAS como dicas de restaurantes, hotéis e até mesmo estacionamentos (dicas com valores :) ). Ahh1 o evento ocorrerá no dia 7 de Novembro de 2009 das 8h às 18h. Parabéns pela organização do evento.

Ahh2 : só pra complementar no final do evento será sorteado um Nintendo Wii. :)

Quer pagar quanto?

2009-10-17T17:15:00.000-07:00

O portal de notícias da Record o R7 foi lançado a alguns dias atrás... até ai nada de anormal, certo?! Pois bem, fui verificar quanto valia o portal de acordo com o BizInformation. Se você ainda não conhece, se trata de um site que baseado em diversos parametros informa quanto seu site vale. Logo a primeira reação foi me assustar com o resultado para o site R7.com :

R$2.692,79

Somente isso! Imaginem meu site alternativo the empyrean foi cotado ao valor de :

$3,946.8

Outro detalhe é que para o site the empyrean foi usado (dolar americano) U$ ,ou seja, meu blog vale mais do que o portal R7 :-) brincadeira....
ps: penso que está claro o fato de que, o BizInformation, nesse caso do portal R7, falhou nas suas estátisticas.

Livro DSL In Action

2009-10-07T12:24:00.000-07:00

A friend of mine enviou-me um email informando sobre o livro DSL In Action (ainda não pronto) para uma possível pré-leitura. Há até mesmo um capítulo no site. Pelo capítulo grátis pra degustação, penso que o livro pode ser um grande amigão, gostei da forma com que o autor trata o assunto domain-specific language - dsl - e por isso fica a dica aqui de uma boa leitura. C0m certeza mais um livro a se somar na pilha de livros sobre dsl.

Usar sempre a interface mais genérica possível

2009-09-25T05:37:00.000-07:00

Se você precisa somente iterar sobre uma coleção de um tipo de objeto...
Faça seuMetodoReceber(Collection colecao); e não uma List ou Set... (ou ainda uma Iterable)

Se você vai trabalhar num nível muito baixo com Stream...
Faça seuMetodoReceber(InputStream is); e não um FileInputStream...

Essa lista segue sem fim...

Porque sempre usar a interface mais genérica possível?

Você pode simplesmente mudar sua coleção que retornava uma List pra retortar uma TreeSet. Mudar o comportamento esperado, mudar o Stream para outro tipo e outras coisas que são comuns, sem sofrer tanto. Se você nunca enfrentou o inferno das manutenções não entenderá completamente a dor.

Se você está pensando em criar uma biblioteca então essa consideração deve ser ter atenção redobrada.

Opte sempre pelo mais GENÉRICO possível.

Aprendendo com seu IDE

2009-09-23T07:26:00.000-07:00

Estou trabalhando em um projeto que utiliza Swing e o Netbeans. Ate aí nenhuma novidade... mas no decorrer da criação e do uso dos JComponents notei que o netbeans cria algumas coisas bizarras e outras legais... Tudo pra deixar o usuário (eu) feliz com as pedras no sapato da JTable. Bem o interessante não é nada disso... vou ao exemplo que facilitará.

Suponha que você tenha uma classe:

public class ClasseA{
  public void fazNada(){
     System.out.println("nada");
   }
}

E uma classe de teste:

public class TestClasseA{
  public static void main(String[] args){ 
    ClasseA a =  new ClasseA(); 
    a.fazNada(); 
 } 
}

O resultado será simples um nada
Bem e se eu quisesse alterar o comportamento do método fazNada... normalmente o que as pessoas fazem é (além de seguir um dos Patterns do GOF... esqueci o nome :S ) criar uma outra classe herdando da ClasseA e sobreescrevendo o comportamento para o método fazNada.

O que notei que o netbeans faz é o seguinte:


public class TestClasseA{ 
public static void main(String[] args){
      ClasseA a =  new ClasseA(){
           public void fazNada(){
                   System.out.println("tudo");
           }
      }; 
      a.fazNada(); 
} 
}

Isso mesmo sobreescrevendo-a na própria "instanciação"... a essa técnica, ou jeito, penso que o nome correto é classe anónima... (já vi vários usos para classes anónimas, mas esse foi novo.)

Ajuda fútil com progress bar ou outro componente que registre o progresso

2009-09-15T06:57:00.000-07:00

Suponha que você tenha um progress bar que vai de UM_VALOR_MIN até UM_VALOR_MAX em unidades inteiras. Agora suponha que você tenha uma LISTA_DE_ARQUIVOS e deseja fazer um processamento(com_cada_um_dos_arquivos). E também quer deixar visível ao usuário esse progresso.
Agora veja o algoritmo mais (f)útil pra isso.

ps: esse é mais um daqueles posts que você pode se arrepender, tanto de ler quanto de escrever no futuro.

LISTA_DE_ARQUIVOS = listFilesAt("/home/myuser/myfolder/movies/")
UM_VALOR_MAX = 100
TOTAL_DE_ITENS = LISTA_DE_ARQUIVOS .tamanho
QTD_POR_ITEM = UM_VALOR_MAX / TOTAL_DE_ITENS
UM_VALOR_MIN = QTD_POR_ITEM

for (String item : LISTA_DE_ARQUIVOS) {
   File file = new File(item)
   processar(file)
   marcarProgresso(round( UM_VALOR_MIN+ 0.059))
   UM_VALOR_MIN+= QTD_POR_ITEM

}

Cache encurtando viagens

2009-09-03T17:22:00.000-07:00

Cache é importante?

Me lembro quando comprei meu processador Atlhon XP 2400, na época tinha o maior cache maior da categoria. Tinha um cache L1 para dados e instruções de 64KB (cada) e L2 com 256KB. Hoje um E8400 tem cache L1 de 32KB pra dados e 32KB para instruções e um L2 com 6MB (compartilhado entre os núcleos) indo além disso um Core i7 adiciona mais um nível (LEVEL) o L3. ( ele tem L1 = 32KB pra dados e 32KB pra instruções, L2 = 4 x 256KB e L3 = 8MB compartilhada com todos núcleos). Bem, se os projetistas de hardware já se preocuparam com isso pra que eu vou fazer cache?

O que é um Cache?

O processo de armazenamento temporário de informações recentemente acessadas em um subsistema de memória especial para acesso mais rápido. (Windows Vista Center Help)
É um dispositivo de acesso rápido, interno a um sistema, que serve de intermediário entre um operador de um processo e o dispositivo de armazenamento ao qual esse operador acede. A vantagem principal na utilização de uma cache consiste em evitar o acesso ao dispositivo de armazenamento - que pode ser demorado -, armazenando os dados em meios de acesso mais rápidos. (Wikipedia)

Exemplo (ridículo) do uso de Cache (sun.misc.Cache)

Cache cache = MCache.get(); //singleton, session, jndi, cache distributed server...
if (cache.get("homePageNews")==null){
//busco no banco
//quando busco no banco
//atualizo também o cache.
}else{
//salvei tempo
Set news = (Set)cache.get("homePageNews");
}

Senta que lá vem história, experiência quase-real

Numa consultoria 0800 à um amigo Php-Ense; ele me retratava que apesar de ser um servidor não tão parrudo o sistema estava apresentando lentidão (demora de 0,5 a 1,8 segundos), as telas estavam demorando muito a serem carregadas... Já cheguei pensando que seria uma batalha(tanto pelo pouco conhecimento em PHP, quanto pela descrição do problema). Se tratava de uma aplicação simples com poucos 'Gruds' (cerca de 30). Na demonstração percebi que algumas telas demoravam mais do que outras para carregar , e uma demorava quase 2 segundos (essa que encomodava-o) que era a gestão de clientes, nela havia três combos: países, estados e cidades. Uma outra era a página inicial que carregava : últimas notícias, o perfil de três clientes (randômicos), três serviços prestados (randômicos), um texto sobre a "empresa" e uma mensagem. Tudo isso era carregado do banco a cada requisição, se 100 pessoas abrissem o browser naquele site seriam enviados 100 equisições ao banco (que provavelmente por se tratar do mesmo dado os teria em cache, ôoo o banco também tem cache, todo mundo têm eu também quero... será? ) mesmo que o banco lhe salve um pouco de processamento, você continua enviando e recebendo dados pela rede e isso é danoso. Sugeri a ele usar um framework de Cache ou criar um simples e sincronizá-lo com a base de N minutos a N minutos. Depois que ele seguiu meus conselhos ele disse ter uma melhora bem melhor do que esperava. Isso, claro, não significa que todos os problemas de performance serão sanados com uso de cache, alias o uso indiscriminado de tal recurso pode também afetar a performance negativamente. Agora imagine que uma aplicação esteja distribuída em vários servidores em clustes um único sistema de Cache não irá ajudar muito, para tanto já existem sistemas de Cache distribuidos (acredite que isso é mais simples do que minha mente temerosa de computação distribuída possa imaginar).

Lista de bons programas open-source.

2009-09-01T06:56:00.000-07:00

Soa como clichê mas vai ai minha lista:

Media Center - http://www.moovida.com/screenshots/
Playstation 2 - http://code.google.com/p/pcsx2/
Wii / Dolphin Emulator - http://code.google.com/p/dolphin-emu/
JDowloader - http://jdownloader.org/

ps: só citei os que estou usando e aproveitando (muito) ultimamente.

Minhas::Commons::Lib::Utils > Apache::Commons

2009-08-14T20:11:00.000-07:00

Por mais que existam frameworks como Jpa, Jsf, Ruby On Rails, Lucene, Spring e outros, provavelmente sempre existirá uma característica ou um pedaço de código que nós desenvolvedores iremos criar e guarda-los em um modulo (pacote...) de utils. Há alguns desenvolvedores que mesmo conscientes de que já existem frameworks de ORM, criam seus próprios produtos. Acredite ainda existem.

Se você é aquele que segue a idéia de não reinventar a roda tente sempre, antes de criar essas "libs", verificar se já há algum código criado pra tal problema.

Pensando nesses problemas a grande Apache criou vários projetos com um subnome de Commons. (tanto para plataforma Java quanto .NET) E são esses projetos (não todos, só alguns) que vou resumir aqui seus usos, a idéia não é dar um guideline de uso dos projetos mas apenas mostrar que para quase toda "vontade" de criar uma lib, já existe uma pronta. Então a use...

Tenho um problema de desempenho que acho que resolveria se mantivesse alguns objetos pesados no pool..

Primeiro tenha certeza de onde está o seu real problema de desempenho, isso você só consegue medindo... dá-lhe profiler. Às vezes não são os poucos objetos pesados, mas a grande quantidade de pequenos repetidos! Bem para esse problema a Apache já criou projeto :) Apache Commons Pool.

Trabalho numa empresa que desenvolveu um sistema para o TRE-XX e lá nos temos que validar títulos de eleitor, isso eu dúvido que apache tenha...

Realmente a apache (eu acho que não, vai saber?!...) parece não ter, mas a Caelum desenvolveu (e está evoluindo) um Framework chamado Stella (http://stella.caelum.com.br/core-formatters.html), justamente para prover soluções para problemas que nós desenvolvedores Brasileiros enfrentamos diariamente, tais como: validar cpf, boletos de bancos nacionais, formatar cnpj e etc.

Pô, uso a API padrão do Java (6) no que tange ao assunto de coleções mas não consigo encontrar várias operações que gostaria de fazer com essas coleções... e ai?

Aqui o conselho seria primeiro dar uma boa olhada nas classes Collections (não a Interface Collection) e a Arrays, elas já provem bastantes características mas se mesmo assim não se der por satisfeito pesquise e irá econtrar uma Collection-Commons (http://commons.apache.org/collections/userguide.html) da Apache.

Tô trabalhando num sistema legado e aqui, por questões de performance, uso o JDBC e tenho que criar, mapear e fazer n coisas de banco, tudo na "mão"...

Performance ... sempre deve ser medida pra ser confirmada. A Apache (novamente) tem um projeto DBUtils (http://commons.apache.org/dbutils/examples.html) que têm várias funcionalidades para manuseio de banco de dados.

Nem sempre as utils vem para só para resolver problemas, às vezes criamos utils para facilitar nosso código.

Pensando assim a Apache também criou uma outra Commons (http://commons.apache.org/io/description.html) para IO, o que torna uma tarefa entediante de ler os bytes de um InputStream numa simples tarefa.

Tarefas como mandar email, realizar operação matemáticas complexas, usar recursos e protocolos das redes de computadores, já estão implementadas, testadas e sendo usadas em produção por várias pessoas.

Por último, pare e pense: porque será que grandes projetos, tais como Hibernate Core ou Search, Spring e outros, tem dependências de grande parte dos projetos xyz-commons-kwq.zip da apache? será mesmo necessário criar aquela util ou mesmo criar uma exceção para dizer que o argumento passado à um método veio nulo?

Tiny Types não são desperdícios

2009-08-12T04:36:00.000-07:00

Tiny Types são importantes por diversos fatores dos quais me lembro de: enriquecimento do domínio, forçagem de tipagem, clientes das classes perdem o poder de errar no uso incorreto da ordem dos parâmetros de algum método.

O que é um tiny type?

Sabe aquelas propriedades que costumamos definir como simplesmente String (nome, sobrenome, cpf, cep) , alguns desses atributos podem acabar se transformando em um tipo próprio.... os tiny types.
Definição: São objetos pequeninos (dahhh) que normalmente são imutáveis e seguem o padrão VO (de Martin Fowler), podem parecer chatos no inícios para alguns mas se mostram poderosos com o passar do tempo.

E as vantagens??

Enriquecimento do domínio: new Pessoa(new Nome("Luiz"), new Sobrenome("Inacio"))
Diminuição de erros: tendo uma classe qualquer Pessoa com atributos nome e sobrenome como String poderia nos permitir fazer coisas como: new Pessoa("Inacio","Luiz")

E as desvantagens???

Claramente você terá mais trabalho para definir e até mesmo mapear (seja o @Embebbed do padrão JPA ou seu mapeador próprio ou seu framework predileto para mapeamento ORM) esses mini-tipos que serão incorporados a um objeto maior.

ps: inspirado (entre outros...) pelo post da caelum.

JRuby, Abobrinhas e DDD

2009-08-11T05:36:00.000-07:00

Programação funcional, linguagem dinâmica, duck typing, closures, fluência, dsl, behavior, tipagem inferida... são assuntos recorrentes das rodas dos desenvolvedores mais cool. Em uma dessas rodas ouvi a seguinte afirmação sobre o JRuby:
"Eu não gosto do JRuby... gosto do Ruby puro, JRuby é apenas os problemas do Java no Ruby"
Isso foi numa roda de "experientes em Java"... claro que tentei explicar que a frase não fazia muito sentido e que deveriamos pensar em Plataforma... e que JRuby é uma implementação para o interpretador de Ruby e não uma linguagem, que era até mesmo mais rápido do que o MRI (ou CRuby para os mais intimos), dai que eles se renderam e entenderam o que era o JRuby e MRI. Eu ainda curioso, perguntei como tinham chegado aquela conclusão, e para minha surpresa um me disse que foi porque veio com NetBeans e por isso não deveria ser coisa boa... (pode? rsrsrsrsr)

Hoje também li um post (ótimo por sinal) do Rodrigo Yoshima (AsperCom) no qual ele discorre o já batido (mas nunca esgotado) assunto Repositories... ele escreveu uma frase ("Não é uma opção arquitetural, somente estou transparecendo o domínio.") que me fez lembrar mais uma vez da falta de cautela dos desenvolvedores ao se preocuparem muito mais em tecnologia do que com a realidade. Certa vez estava realizando um projeto (não UML, na definição das classes mesmo) no qual dividi uma entidade em dois conceitos mas que tinha somente uma tabela no banco, quase 100% das pessoas me criticaram por estar sendo muito purista, naquele momento não sabia exatamente o que dizer à eles mas lembro que o sentimento era que eu estava apenas transcrevendo o que houvi dos usuários.

Aprenda o TInés para se dar bem

2009-07-29T07:06:00.001-07:00

"Com a governança dos processos de negocios facilitada pelo uso de SOA, o alinhamento dos negocios com a T.I. se tornou mais ágil. Nossa empresa também está pensando em levar para as nuvens nossa infra-estrutura de armazenamento."

Escutei, exatamente, isso numa palestra que um CIO apresentava e acredito que ele sabia exatamente o que estava falando. O fato não é se ele sabia ou não o que dizia e sim que todos prestavam com atenção e respeito pelas palavras do homem bem vestido.

Não quero, de jeito algum, diminuir os substantivos (e seus livros, teorias...) mas apenas alertar que usar palavras "corretas" numa entrevista pode te dar vantagens em relação aos outros entrevistados.

Deixe pra discutir se essas buzzwords são modas ou vieram pra ficar com seus amigos ou no seu blog.

Arquitetura e Design de Software Uma visão sobre a plataforma Java drafts....

2009-07-17T04:50:00.000-07:00

No mês de maio de 2009, postei aqui sobre um investimento que você iria fazer que era certeza de ROI!
( pra quem não se lembra clique aqui)

O livro (ainda WIP - Work In Progress) Arquitetura e Design de Software Uma visão sobre a plataforma Java já mostra um pouco da sua cara, o pessoal liberou alguns PDFs iniciais com um pouco do conteúdo do livro (que mais uma vez sai em Novembro desse ano (2009), se tudo correr bem claro!)!

Pra quem deseja fazer o download desses rascunhos iniciais do livro Arquitetura e Design de Software Uma visão sobre a plataforma Java clique aqui.

fonte original: http://blog.caelum.com.br/2009/07/17/livro-arquitetura-e-design-de-software-4-topicos-do-draft-liberados/

JSF 2.0 na prática - Navegação implicíta

2009-07-01T07:10:00.000-07:00

Novas características do JSF 2.0 na prática - Navegação implicíta

Depois do primeiro exemplo (primeiro exemplo), vamos tentar explorar as novas características. A primeira delas, a anotação @ManagedBean, já foi usada no primeiro exemplo.

Navegação padrão...

Cansado ou triste por ter que escrever navigation-rules pra coisas muito obvias... O padrão JSF 2 trouxe dos já-bem-conhecidos frameworks a idéia de só ter que criar uma regra de navegação na exceção, nos casos comuns prevalece o "bom senso"...
Bem o seu bom senso pode ser diferente do meu que pode ser diferente do Super Mario que por sua vez também pode ser diferente do Senhor Abravanel. Leia sobre essa regra em http://blog.gilliard.eti.br/2009/05/implicit-navigation-jsf-2/

De volta ao exemplo

Para demonstrar como essa característica funciona na prática, adicione o seguinte componente a nossa página index.xhtml.

[br /][h:commandButton value="Navegação implícita!" action="login"/]

Além disso crie uma página com nome login.xhtml
[?xml version="1.0" encoding="ISO-8859-1" ?]
[!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"]
[html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"]
[head]
[title]ArchSoftyJSF2[/title]
[/head]
[body]
[h:form]
[h:outputText value="Login!"/]
[/h:form]
[/body]
[/html]

Pronto agora quando clicar no botão [Navegação implícita!] a página que será mostrada será a login.xhtml.

Ainda sem o faces-config.xml!

Exemplo simples usando JavaServer Faces 2.0 (BETA1) JSF 2 + Eclipse Galileo + Tomcat 6x

2009-07-01T06:03:00.000-07:00

O que necessito?

1. Tomcat: http://tomcat.apache.org/download-60.cgi (ou algo que "rode" a espec. JSP2.5)
2. JSF 2.0 BETA1: https://javaserverfaces.dev.java.net/files/documents/1866/135560/mojarra-2.0.0-Beta1-binary.zip
3. Eclispe Galileo: http://www.eclipse.org/downloads/ (ou Netbeans 6.7, gnome-editor, vi, notepad...)
4. JDK 6.0: http://java.sun.com/javase/downloads/index.jsp

Primeiro passo.

Crie um projeto java web. No caso especifico do Eclipse essa categoria se chama: "Dynamic Web Project", nomei o projeto como desejar, eu usarei o nome "ArchSoftyJSF2"; ainda no Eclipse escolhi como "Target runtime" o Apache Tomcat v6.0 e já cliquei em Finish.

Segundo passo.

Coloque os dois jars - jsf-api.jar e jsf-impl.jar - no classpath da aplicação.

Terceiro passo.

Modifique o arquivo web.xml, adicionando um Servlet.
[servlet]
[servlet-name]Faces Servlet[/servlet-name]
[servlet-class]javax.faces.webapp.FacesServlet[/servlet-class]
[/servlet]

[servlet-mapping]
[servlet-name]Faces Servlet[/servlet-name]
[url-pattern]*.jsf[/url-pattern]
[/servlet-mapping]

Quarto passo.

Crie um arquivo (index.xhtml) com o seguinte conteúdo.

[?xml version="1.0" encoding="ISO-8859-1" ?]
[!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"]
[html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"]
[head]
[title]ArchSoftyJSF2[/title]
[/head]
[body]
[h:form]
[h:outputText value="Alô, Mundão!"/]
[/h:form]
[/body]
[/html]

Quinto passo.

Rode e verá sua primeira aplicação usando Jsf 2.0 funcionando. Claro que se trata de um exemplo bem simples, pra deixar mais interessante vamos adicionar um botão e usar o novo modelo de managed bean (digo modelo no sentido de criação por meio de annotations).

Sexto passo.

Crie uma classe Java:

package presentation;

import javax.faces.bean.ManagedBean;

@ManagedBean(name="primeiroBean")
public class PrimeiroBeanMB {
private String texto;

public String getTexto() {
return texto;
}

public void setTexto(String texto) {
this.texto = texto;
}

public void mudeOTexto(){
texto = "Texto modificado!";
System.out.println(texto);
}
}

Sétimo passo.

Altere o index.xhtml mais precisamente mude o interior de ...

[h:form]
[h:outputText value="Alô, Mundão!"/]
[h:commandButton value="Mudar o texto" action="#{primeiroBean.mudeOTexto}"/]
[h:outputText value="#{primeiroBean.texto}"/]
[/h:form]

Agora é só rodar... Sentiu a ausência do faces-config.xml?

ps: desculpe a preguiça de apenas mudar <<>> por ]

Investimento Certo em Novembro de 2009 Arquitetura e Design de Software - Uma visão sobre a plataforma Java

2009-05-28T04:47:00.000-07:00

Em novembro de 2009 você tem um grande investimento para fazer, desta vez não se trata de aplicações na Poupança ou mesmo CDB e sim num livro que a editora Elsevier irá publicar.

O livro intitulado: Arquitetura e Design de Software - Uma visão sobre a plataforma Java (que já possui um site http://www.arquiteturajava.com.br/) foi escrito por "nada mais nada menos" que: Fábio Kung, Guilherme Moreira, Nico Steppat, Paulo Silveira e Sérgio Lopes (Caelum não lhe veio a cabeça?).

"O prefácio de Phillip Calçado já deixa bem claro que não há uma arquitetura de caixinha, e de que cada caso deve ser estudado a fundo."

Não é preciso dizer mais nada...
O draft inicial dos conteúdos:

Arquitetura pré-pronta de caixinha? Prefácio de Phillip Calçado
Introdução
Plataforma Java
1. Java como plataforma, não como linguagem
2. Gerenciar memória não é simples
3. Otimizacao prematura é a raiz de todo mal
4. Tome cuidado com o ciclo de vida de objetos caros
5. A comunidade Java - do JCP aos fóruns
6. A burocracia e o lado ruim das especificações
7. A linguagem certa para cada tarefa
Tópicos de Orientação a Objetos
1. Evite herança, favoreça composição
2. Programe voltado a interface, não a implementação
3. Prefira a imutabilidade
4. Cuidado com a criação indiscriminada de getters e setters
5. Modelo anêmico
6. Domain-Driven Design
7. O Código e a Linguagem Ubíqua
Java avançado
1. Refletindo seu código
2. Configurando: anotações e XML
3. Entendendo o NoSuchMethodError e o ClassLoader hell
4. Manipulação de bytecode
Design
1. Baixo acoplamento, alta coesão
2. Inversão de Controle: Cadê a minha chave de fenda?
3. Fábricas e o mito do baixo acoplamento
4. O que preciso para ser IoC-based?
Arquitetura
1. Camadas e Camadas: a confusão de tiers e layers
2. Granularidade correta: Minimize a comunicação entre tiers
3. Model View Controller
4. Dois tiers
5. Tres tiers
6. N-tiers
7. Mensageria assíncrona
Frameworks e especificações Java EE
1. Enterprise Java Beans
2. JavaServer Faces facilita a criação de interfaces?
3. Considere usar uma ferramente de mapeamento objeto relacional
4. Logar é melhor que debugar
5. Evite escrever seu proprio framework
6. Injeção de dependência
SOA - Same Old Architecture?
1. A burocratização do SOAP vale a pena?
2. Não escreva XML dentro de XML: não veja XML
3. Considere um outro protocolo leve
4. SOA: Same Old Architecture?
Web 2.0
Segurança

Mais sobre o livro Arquitetura e Design de Software - Uma visão sobre a plataforma Java no site http://www.arquiteturajava.com.br/

Tutorial Jogl - Desenhando em Java com Jogl 2D

2009-05-11T07:36:00.000-07:00

Depois te fazer sua primeira tela usando o Jogl agora iremos para parte final desse tutorial.

Para desenharmos no Jogl iremos usar seus eventos. Há uma interface (GLEventListener) que devemos implementar se quisermos desenhar. Uma implementação nula (ou mock) pode ser vista abaixo:

import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLEventListener;

public class OuvinteJogl implements GLEventListener {
public void init(GLAutoDrawable arg0) {
}

public void display(GLAutoDrawable arg0) {
}

public void reshape(GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4) {
}

public void displayChanged(GLAutoDrawable arg0, boolean arg1, boolean arg2) {
}
}

Se concentre em dois métodos, o init e o display ambos recebem um GLAutoDrawable. Esse GLAutoDrawable será o nosso GLCanvas, assim as mudanças que faremos em GLAutoDrawable irão refletir diretamente no nosso GLCanvas.

Método init

Começemos então pelo método init que irá inicializar nosso desenho.
public void init(GLAutoDrawable drawable) {
int width = 512, height = 256;
GL gl = drawable.getGL();
GLU glu = new GLU();
gl.glClearColor(.0f, .0f, .0f, 1.0f);
gl.glViewport(0, 0, width, height);
gl.glMatrixMode(GL.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluOrtho2D(0.0, width, 0.0, height);
}
Aqui basicamente defini uma resolução (largura x altura). A segunda linha do méotodo é importantissíma veja como extrai o objeto GL (que na verdade é a API da OpenGl) e nele que iremos trabalhar diretamente com "a linguagem opengl". Esse GLU é uma biblioteca que nos ajuda nas tarefas rotineiras do opengl.

Depois de ter o contexto da opengl (gl) o código foi basicamente de inicialazação de um plano 2D (sem profundidade) na resolução dada.

Método display

Agora sim, nesse método que iremos criar o código para desenharmos a tv desintonizada usando o jogl.
public void display(GLAutoDrawable drawable) {
GL gl = drawable.getGL();
gl.glClear(GL.GL_COLOR_BUFFER_BIT);

gl.glBegin(GL.GL_POINTS);
for (int x = 0; x < y =" 0;">

Simples. Aqui da mesma forma o primeiro passo é adiquirir o contexto da OpenGL (representado pelo objeto GL no java), limpar as cores gl.glClear(GL.GL_COLOR_BUFFER_BIT) e começar a desenhar pontos na tela. A logica é simples percorre-se dois for's uma para x e outro para y, a cada ponto uma cor é setada usando o método random da biblioteca Math (padrão do Java).

Agora pra juntar isso ao nosso JFrame anterior... ?
Simples basta ligar o nosso Listener ao Canvas.

super("OpenGl 2D - Java 2D com opengl Jogl");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(514, 258);
GLCanvas canvas = new GLCanvas();
canvas.addGLEventListener(new OuvinteJogl());
add(canvas);

Simples, não?
Execute e veja o resultado!

Mas perai... alguém me enganou! Isso não é animado...
É ai que entra o 3º Componente o FPSAnimator.
Ainda no construtor... escreva após a última linha de código existente nele.

FPSAnimator animator = new FPSAnimator(canvas, 50);
animator.start();

Agora execute e veja. (aquel 50 é o número de fps) Pronto igualzinho aquele tempo que a TV te dava canseira com o Super Nintendo e o Video Cassete.

Links:

Código Final Completo.
import com.sun.opengl.util.FPSAnimator;
import javax.media.opengl.GLCanvas;
import javax.swing.JFrame;

public class FrameJogl extends JFrame {

public static void main(String[] args) {
new FrameJogl().setVisible(true);
}

public FrameJogl() {
super("OpenGl 2D - Java 2D com opengl Jogl");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(514, 258);
GLCanvas canvas = new GLCanvas();
canvas.addGLEventListener(new OuvinteJogl());
add(canvas);
FPSAnimator animator = new FPSAnimator(canvas, 50);
animator.start();
}
}

import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.glu.GLU;

public class OuvinteJogl implements GLEventListener {

public void init(GLAutoDrawable drawable) {
int width = 512, height = 256;
GL gl = drawable.getGL();
GLU glu = new GLU();
gl.glClearColor(.0f, .0f, .0f, 1.0f);
gl.glViewport(0, 0, width, height);
gl.glMatrixMode(GL.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluOrtho2D(0.0, width, 0.0, height);
}

public void display(GLAutoDrawable drawable) {
GL gl = drawable.getGL();
gl.glClear(GL.GL_COLOR_BUFFER_BIT);

gl.glBegin(GL.GL_POINTS);
for (int x = 0; x < 512; x++) {
for (int y = 0; y < 256; y++) {
gl.glColor3f((float)Math.random(), (float)Math.random(), (float)Math.random());
gl.glVertex2i(x, y);
}
}
gl.glEnd();
}

public void reshape(GLAutoDrawable drawable, int arg1, int arg2, int arg3, int arg4) {
}

public void displayChanged(GLAutoDrawable drawable, boolean arg1, boolean arg2) {
}
}

Tutorial JOGL - Configuração do ambiente

2009-05-11T07:04:00.000-07:00

Primeira Parte - Configurando Jogl no Netbeans

O primeiro passo é ir ao site do jogl e baixar a versão correspondente ao seu sistema operacional. No meu exemplo estou usando o Windows portando baixei desse link http://download.java.net/media/jogl/builds/archive/jsr-231-1.1.1/jogl-1.1.1-windows-i586.zip . Dentro do arquivo comprimido haverá uma pasta lib vário arquivos:

gluegen-rt.dll
gluegen-rt.jar
jogl.dll
jogl.jar
jogl_awt.dll
jogl_cg.dll

Note que se você estiver usando linux ao invés de *.dll terá os arquivos *.so.

Como em qualquer outro desenvolvimento uma IDE poderá te ajudar e muito, escolha a sua preferida. Estou usando o NetBeans 6.5. (Que não necessariamente é minha IDE preferida ;) )

Conceitos sobre Jogl

Quando você está criando uma aplicação que irá lançar mão de recursos providos pelo OpenGL há básicamente três componentes que poderão facilitar e muito sua vida. São eles:

GLCanvas (ou GLPanel) - Um componente (que extend de Component do AWT).
GLEventListener - O modelo de listener para os eventos comuns do opengl.
FPSAnimator - Uma classe que irá lhe ajudar a efetivamente fazer seus desenhos (ou jogos) animarem.

Criando um projeto...

Crie um projeto e adicione à ele as bibliotecas (gluegen-rt.jar e jogl.jar), copie também para pasta raiz do projeto todas as *.dll que estavam na pasta lib (do arquivo baixado anteriormente).

Para simplicar bastante as coisas (assim deixando de mais fácil entendimento para todos) iremos criar um JFrame e mostraremos nesse JFrame nossa animação.

O código pode ser visto abaixo:

import javax.swing.JFrame;
public class FrameJogl extends JFrame {

public static void main(String[] args) {
new FrameJogl().setVisible(true);
}

public FrameJogl() {
super("OpenGl 2D - Java 2D com opengl Jogl");
setSize(514, 258);
}
}

Simples ao extremo. Apenas cria um JFrame atribuindo o tamanho de 514 pixels de comprimento por 258 pixels de altura.

O próximo passo é escrever o componente que irá mostrar a tela opengl dentro desse JFrame. Para tal tarefa apenas escrevemos:

GLCanvas canvas = new GLCanvas();
add(canvas);

Isso, claro, no construtor abaixo de setSize. Agora se executarmos a aplicação teremos algo semelhando a isso abaixo.

Sua máquina irá mostrar algo diferente, como não definimos nada o "opengl" mostra dados randômicos da sua memoria RAM. O importante neste ponto é a simplicidade do código, com pouco código já se pode ver algo produzido pelo Jogl.

O meu código final para o JFrame ficou assim:

import javax.media.opengl.GLCanvas;
import javax.swing.JFrame;

public class FrameJogl extends JFrame {

public static void main(String[] args) {
new FrameJogl().setVisible(true);
}

public FrameJogl() {
super("OpenGl 2D - Java 2D com opengl Jogl");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(514, 258);
GLCanvas canvas = new GLCanvas();
add(canvas);
}
}

Note que também adicionei um comportamente padrão para quando o usuário clicar no botão X da Janela.

Links:

Jogl - Java bindings for OpenGL API with OpenGL 1.5 specification

2009-05-11T06:50:00.000-07:00

Pretendo nos próximos posts explicar sobre como utilizar a API OpenGL no Java. Especificamente o "framework" Jogl.
Essas primeiras partes abordaram o básico ( não pretendo aprofundar muito nos conceitos, mostrar só a prática mesmo ) e o produto final desse tutorial - se assim posso chamar - será um programa que irá desenhar, em uma tela, pixels com cores randômicas... similar ao efeito de uma tv desintonizada.

Links:

DSL Interna ou DSL Externa dão brigas feias

2009-04-22T07:13:00.000-07:00

O assunto interessantissímo DSL (domain-specific language) é contraverso (assim como a maioria das tecnicas/metodologias/tecnologias novas) e chega a dar briga!

Acompanho direto foruns e artigos sobre o assunto, para alguns ela é dividida em dois ramos dsl interna e externa, pra outros essa divisão é sem sentido. A discussão já começa na definição do conceito ou conjunto de conceitos por trás do assunto.

Leia a opinião de Martin Fowler sobre DSL's (interna e/ou externa): DSL (domain-specific language)
Leia também a opinião de Phillip Calçado: Domain-Specific Language Interna

E por último não deixe de conferir este artigo no infoq: http://www.infoq.com/articles/External-DSL-Vaughn-Vernon

Lula on South Park

2009-04-17T05:27:00.000-07:00

Este post vai fugir bastante (no fundo acho que não) do usual aqui. Ontem assisti o novo episódio (transmitido na quarta) de south park, nele os grandes líderes do mundo aparecem and Guess Who.... Mister Lula também aparece. Não sou daqueles a favor do Lula muito ao contrário sou sempre um vigia do atual governo. Mas achei muito bom a aparição dele "entre os líderes mundiais" bem como o episódio. Esta temporada de south park está de mais, o melhor episódio IMHO foi Gay Fish. (hilário)

Spring, spring meu existe alguém que te usa mais do que eu

2009-03-18T12:51:00.000-07:00

Sem dúvida um dos frameworks mais agitados e falados (e usados também) ultimamente é o senhor Spring Framework. Eu há muito tempo (muito mesmo) já gostei da idéia, mas porém contudo todavia tenho hoje uma visão crítica de que não é TODO projeto que se deve usar (ou ao menos em todos os componentes) o mesmo. Essa opinião foi formada devido a um projeto que estive trabalhando nesses últimos meses. Resumidamente o projeto tinha mais ou menos a arquitetura abaixo. (apenas estava servindo como reparador não foi eu que criei)

As dependencias das actions são todas gerenciadas pelo "container" (Spring), logo nas actions só se tem declaração de interfaces (no exemplo qualquer classe sem Imp era uma interface) e o Spring faz a injenção com as classes que as implementa (ClasseImp.java) e isso sucessivamente, ou seja, as dependencias das classes de "negocios" também...

Em si isso é comum, o fato não é o jeito que as coisas foram feitas e sim o motivo, nesse projeto pode se reduzir BASTANTE o uso do Spring mas ao contrário as pessoas apenas querem usar desefreadamente os frameworks em voga.

Eu acredito que o uso de qualquer framework exige um senso apurado assim como uma visão crítica, há projetos em que o uso de JPA pode degradar a performance final e assim como vários outros exemplos de que nem sempre é necessário estar na "moda".

Usar por usar (sem saber o pôrque) não vale a pena! Veja e tente entender os beneficios de se usar esse ou aquele framework ou mesmo alguma metodologia!

Bons e Novos Jogos!

2009-03-17T04:30:00.000-07:00

Influenciado fortemente pelo post no meu outro blog em inglês trago hoje (para uns) novidade na cena da criação de jogos!

Ultimamente estou observando de muito perto a criação de alguns jogos independentes. Especificamente três jogos me tomaram totalmente a atenção; são eles: Braid, Aquaria e Crayon Physics. Se você é daqueles que ainda se lembra da caixa do super nintendo ou do mega drive, dê uma chance a esses jogos.

Braid (a versão pra PC sairá dia 31 de Março de 2009)

Um jogo no estilo Super Mario (alias até é meio que uma homenagem) e com uma história depressiva e imperdivel.
Official site: braid-game.com/

Aquaria (já disponivel)

Um épico dos RPGs 2D... se você gosta do estilo, irá amar joga-lo, vai sentir nostalgia e com certeza se lembrará de jogos como... Castlevania!
Official Site: http://www.bit-blot.com/aquaria/

Crayon physics (já disponivel)Esse jogo não encontrei meios ou palavras pra descreve-lo, é incrivel a única coisa que posso dizer é: Entre no site e assista o vídeo de demonstração.... veja vale MUITO a pena!
Official Site: www.crayonphysics.com/

Ofereço trabalho de FreeLancer em Java

2009-03-16T05:06:00.000-07:00

Olá à todos,

Estou interessado a trabalhar em projetos Freelance (pagos), se tiver algum ou conhecer pessoas que necessitem favor me contactar pelo email: leandro.ribeiro.moreira at Gmail ou ainda comentando neste post.

Tenho experiências com desenvolvimento de aplicações Java a mais de 3 anos (com artigo publicado na revista MundoJ, artigo públicado na infoQ gringa e algumas participações em projetos open-source) , meu foco se baseia principalmente em aplicações Web (Jsf [myfaces, icefaces e richfaces], Jpa, Ejb3, DWR, Jasper, Spring-Framework ...) . Integração de aplicações, DSL, SOA, TDD, DDD são algumas das áreas de conhecimento que atuo. Se estiver interessado posso enviar meu curriculo à você.

No mais obrigado :) Have a nice day!

Abordagens e Abordagens

2009-03-11T12:29:00.000-07:00

Motivado por uma discussão calorosa sobre meu projeto e o extremismo do OO (no forum WTF daily) o projeto recebeu mais de 500 visitas num só dia, a principal crítica era sobre a quantidade de classes (uma por cada opCode) desnecessárias... o que fez com que os gringos classificassem o projeto como WTF do OO (claro que dentro da discussão haviam aqueles que não achavam que o projeto deveria ganhar esse título também).

Resumidamente o processador do nintendo 8bits é um 6502 modificado, a sua arquitetura conta com 11 meios de se obter os operadores (basicamente em baixo nível você tem uma instrução e os operadores pra mesma), com isso a mesma operação pode ser feita de várias formas...

Exemplo: Para a instrução STA (carregue o registrador Accumulator) existem várias STA's: STA $10, STA ($10),Y , STA $1002 ... (sta direta, sta indexeda por y, sta indireta....)

Logo criou-se a situação de que eu tomei a decisão de uma interface Instrução e criei várias classes abstratas InstrucaoAbsoluta, InstrucaoRelativa, InstrucaoIndexadaY ... e várias subclasses concretas LDAAbsoluta, LDARelativa... (sendo que o trabalho de se obter o operador ficaria a cargo da classe pai).

Com isso tenho REALMENTE MUITAS CLASSES isso foi uma das reclamações. Hoje penso que poderia (e ainda posso mas ando focado no debugger) fazer algo mais ou menos assim.
lda(immediate());
lda(absolute());
sta(immediate());
sta(absolute());
Só isso reduziria e muito o número de classes apenas com a composição correta delas.

A outra indagação é sobre o meio que usei para se interpretar cada opcode. Normalmente um interpretador agi mais ou menos assim:

switch(coisaASerInterpretada){
case 0xFA: fazA();
case 0xFB: fazB();
}

E minha abordagem foi diferente, coloquei todas as "funções" num hashmap generic e apenas executava.

O preenchimento:
hash.add(0xFA,new FazA());
hash.add(0xFB,new FazB());
Quando fosse usar:
hash.get(coisaASerInterpretada).execute();

Eles não discordaram do jeito que fiz as coisas; mas de ter usado HashMap ao invés de um simples array. Acredito que realmente seja verdade, é desperdício usar um HashMap ao invés de um array comum mas nesse caso prefiro correr "esse risco bobo calculado" a ter que declarar uma array maior do que o necessário já que o índice do vetor seria a identificação da operação e aproveitar das facilidades do hashmap (melhor ainda pra buscas...).

Não posso deixar de rir um pouco com as opiniões xiitas mas também não concordo que isso poderia fazer um projeto ser classificado como um WTF (what the f%ck)

Meu novo projeto JNesBR

2009-03-11T06:37:00.000-07:00

O meu atual hobbie preferido é criar emuladores (máquinas virtuais, simuladores, emuladores + simuladores), agora estou "desenhando" um emulador da máquina Nintendo 8Bits (NES ou FAMICOM). As minhas motivações para o hobbie são (entre outras):

Amar videogames/computadores e entender como realmente eles funcionam [bit a bit mesmo no mais baixo nivel].
Criar um sistema onde eu posso realmente empregar oo em vários sentidos, dar soluções flexiveis para os problemas mais desconhecidos.
Criar um sistema bom de debugger. (isso é muito legal, ver seus breakpoints nos assemblers, criar interfaces e objetos que lhe possibilitem caminhar no código, ver valores, enfim foge muito dos CRUD's de cada dia [amém graças a Deus])

É interessante ressaltar que a quantidade de conhecimento que você obtem ao escrever um emulador é gigante, você passa desde conceitos de memoria (páginação, troca) a controladores de vídeo (compactação, paleta de cores, conceitos sobre computação gráfica 2d e 3d...).
Espero postar mais sobre essas experiências e também alguns screenshots.
A página do projeto é http://code.google.com/p/jnesbr/

Aumente pessoas e seu projeto terá os objetivos atingidos mais rapidamente....

2009-03-06T05:21:00.001-08:00

Desde que fiz faculdade, e já faz dois anos, TODA a bibliografia SEMPRE dizia: ter muitas pessoas num projeto não garante que ele vá terminar mais rápido.
E AINDA HOJE TEM pessoas da alta gerência que resolvem dar gás ao projeto inserido mais 20 colaboradores (não estou afirmando que às vezes é necessário mais pessoas). E depois a cobrança é mais idiota : "Um projeto com 15 pessoas teria que terminar mais rápido"... ah vai ler qualquer texto sobre gerência de projetos...

GIT, SVN, CVS, SourceSafe etc. Podem tirar suas fóbias de comentar código

2009-03-02T11:54:00.000-08:00

Sabe aquele código comentado em produção que ninguém mexe e ainda dizem de modo obscuro... "Isso aí é coisa legada melhor deixar, vai que um dia tenhamos que descomentar..."

Eu (sempre) prefiro tirar todo lixo do código (isso claro que inclui códigos comentados), mas para aqueles que ainda sentem calafrios ao excluir código comentado segue uma velha dica, qualquer (que conheço) sistema de versionamento oferece ÓTIMOS e eficientes meios para que você possa "voltar" aquele comentário obscuro ...

UseCASE Generator - Viva a documentação

2009-02-18T04:42:00.000-08:00

Se você está atualmente empregado em uma empresa que adota documentações parecidas com isso abaixo:

---------------------------------------
Identificação: 1
Envolvidos: Mariana, Pedro e Luís
Caso de Uso: Manter Empregado
Ações:

Clicar em novo Empregado.
Inserir dados (nome, cpf, nascimento, salário, departamento) do Empregado.
Clicar em salvar.

Exeções:

Empregado não encontrado.
Não foi possível salvar.

---------------------------------------

ou

---------------------------------------
Identificação: 2
Envolvidos: Mariana, Pedro e Luís
Caso de Uso: Manter Departamento
Ações:

Clicar em novo Departamento.
Inserir dados (nome, sala) do Departamento.
Clicar em salvar.

Exeções:

Departamento não encontrado.
Não foi possível salvar.

---------------------------------------

Logo você precisa do UseCASE Generator Java V. 1.0 OpenSouce. (apesar de ser opensource o código não está disponível :P faça o seu)

Veja a API riquíssima.
public String createUseCase(int id, String[] stakeHolders, String entity, String[] properties);

Exemplo de uso:

String minhaSalvacao = useCASEGenerator.createUseCase(1,
new String{"Mariana","Pedro","Luís"},
"Empregado",
new String{"nome", "cpf", "nascimento", "salário", "departamento"});
System.out.println(minhaSalvacao);

Notou como é simples...
Pense rápido: se você consegue generalizar criar "case use generator" logo você não precisa documentar, apenas escreva um programa (já que sua empresa exige isso) que faça isso pra você.

PS: Essa ideia do UseCASE Generator é de um amigão (Marlos) e já está patenteada, portanto crie seus próprios UseCASE Generator e viva a documentação.

TDD - Desenvolvimento Guiado por Testes

2009-02-18T03:58:00.000-08:00

Sei que esse assunto já foi e é explorado em n locais de n diferentes formas, mesmo assim vejo gente "confundindo tudo" e perguntas do tipo:

Posso usar DDD com TDD? (sim)
TDD pode ser usado em processos não-ageis? (sim)
TDD não é perda de tempo? (eu acho que não)
Faço testes no meu processo, estou usando TDD? (depende)

A teoria de testes no desenvolvimento de sistemas é extensa, neste pequeno post não será possivel explicar cada conceito por tras dela ao contrário disso irei tentar explicar apenas o Ciclo (descaradamente inspirada no exemplo do livro).

Ciclo
1º Adicione um teste
Antes mesmo de criar o código real que irá ser testado.
2º Rode os testes e veja se os novos falham
Primeiro faça o teste falhar, geralmente escrevemos código falso.
ex: assertEquals("esperado",objeto.getRetornaNull());
3º Escreva um pouco de código
Escreva um pouco de código para fazer o teste funcionar.
4º Rode os testes automatizados e os veja funcionando
Agrege-os a sua base de testes automatizados (que pode ou deve ser rodado sempre num processo de build automatizado também).
5º Refatore o código
Agora você pode ter o tempo pra dar uma melhorada no design atual, refatoração é a ordem.
ps: refatore tanto o código da aplicação quanto os testes.
6º Volte para o passo 1
Apenas a repetição do processo. (claro que em uma nova estoria/caso de uso/whatever)

Pra finalizar minha opinião: testes são tão importantes quanto o código final . (é algo que atesta sua qualidade executavel.) ahh e leia um bom livro sobre TDD acredito que irá achar a leitura agradavel.

Regras de negócio OO vs Condicionais

2009-01-27T08:10:00.000-08:00

O que é uma regra de negócio ?
São todas as regras existentes num sistema de informação, que ditam seu comportamento, suas restrições e validações. ( Wikipédia )

Imaginemos um sistema de cadastro de usuários (com regras bem pobres, mas que já são o bastante pra exemplificar a construção de regras no software) um conjunto válido de regras poderia ser:

1 - Só se pode cadastrar usuário que tem o nome de usuário com mais de 6 letras.
2 - As senhas deverão ter no mínimo 6 letras e no máximo 8 letras.
3 - Só será possível logar no sistema aqueles usuários que informarem a data de nascimento deles.

Condicionais

Numa abordagem condicional poderiamos ter.

if (! facade.cadastrar(usuario)){
showMessage("Erro ao cadastrar");
}

public boolean cadastrar(Usuario usr){
if (usr.nomeUsuario.length()<=6){
return false;
}
if (usr.senha.length()<6>8){
return false;
}
return true;
}

Mais oo

As regras estariam (ou deveriam) no próprio objeto e ele deveria reger todas as chamadas à ele.

public void setNomeUsuario(String user){
if (user.length() <=6) throw new NomeUsuarioInvalidoException("O nome deve conter no mínimo 7 letras.");
}

O simples fato de dar comportamente a quem interessa tal comportamente (GRASP) já é um avanço nos projetos de software. A maioria dos desenvolvedores ficam encantados com Spring ou mesmo discutindo qual melhor uso dos Daos ou Repositorios mas quase todos se esquecem que um bom projeto é o simples fato de entender e modelar os problemas da maneira mais adequada ao seu contexto. (seja oo, xx , ss ou yy)

* Tente sempre que possível codificar suas regras de negócio nos objetos (entidades).
* Não dito que usar if's é errado mas que pode ser um "cheiro" de que algo está errado ou caminhando pra rumo errado.
* O título ficou meio idiota no fim programas são sempre "condições" todavia não uma enxurada de condições encuraladas.

JChip8BR

2009-01-18T01:32:00.000-08:00

Chip8 e SChip8 escritos em Java

Chip8 é o projeto padrão para aqueles que desejam se iniciar no desenvolvimento de um emulator (ou máquina virtual, ou misto de simulador com emulação ou etc.) Este projeto é outro exemplo de como implementar essa "máquina". A linguagem que escolhi foi Java e pra renderizar usei o Java2D mesmo. Um simples (mas usual) debugador está também no JChip8BR e uma ferramenta (essa acho que pode ajudar) de "disassemblar" com o assembler em duas notações a do David Winter e do Michael Toren.

Screenshots

Página do projeto
JChip8BR

Java e os tipos sem sinais (unsigned types)

2009-01-16T07:31:00.000-08:00

"A grande maioria dos desenvolvedores Java (bem como outras linguagens tipadas) quando necessitam representar algum número inteiro provavelmente usam int. Antigamente as pessoas tinham maiores preocupações com a quantidade de memória disponível, hoje nem tanto. Contudo há uma nova gama de aplicações pra celular surgindo e nesses casos otimização é uma obrigação."

(alguém me disse isso em algum momento...)

Se fossemos criar um atributo pra representar o número de cadeiras numa sala (tendo em vista que está sala não suporta mais de 240 cadeiras) poderíamos usar int, short ou byte. (claro que aqui caberiam outros tipos como char, String, double... )

Usar int ou short seria desperdício de memória!
Logo podemos utilizar byte?!

Nem tão rápido, 1 byte pode caber "256" números diferentes...
Em Java o byte tem 256 "posições" mas essas são preenchidas com os seguinte números -127 a 127.

Ou seja se você somar:
byte x = 127;
byte y = (byte)(x + 1);
System.out.println("x="+x);
System.out.println("y="+y);
você terá, ao invés de 128, y = -127.

O Wraparound do tipo byte
Com sinal:
-127 .. -100 .. 0 .. 1 .. 127 (127 + 1 == -127)

Sem sinal:
0 .. 100 .. 200 .. 255 ( 255 + 1 == 0)

Como extrair o byte sem sinal de um byte em Java? (tem como retornar o valor sem sinal?)

Simplesmente :
public static short readUnsignedByte(byte value){
return (short) (value & 0xff);
}

Se você passar -127 o método vai devolver o 128 e assim por diante. (claro que o retorno é short e não byte.)

Os altos e baixos da qualidade na conexão 3G! - parte 2

2009-01-15T15:18:00.000-08:00

Os altos e baixos da qualidade na conexão 3G!

O post do link acima... foi escrito há um tempo atrás...
Depois disso tive experiências com outras operadoras e outros modelos de modems.
Estou assustado com a melhoria de qualidade quando, usando a mesma brt, troquei de modem (um modelo mais novo). Claro que também pode ter sido que o sinal 3G na minha região tenha melhorado e não o modem.

Esse novo modelo de modem, que está na forma de um pendrive da cor branca, parece aceitar mais um protocolo de comunicação (além de demonstrar uma clara melhoria na "escolha automática" dos mesmos).

Como não tenho o velho modem (o da cor preta com formato retangular) pra testar não posso apenas lhe dar um conselho (tipo, troque de modem), mas se for possível à você realize um teste com esse "novo modelo" da zte.

Brincando com constantes

2008-12-17T12:34:00.001-08:00

Tudo começa com um simples programa que imprime o nome e o sobrenome.

package exemplo.entidade;

public class Testadora {

public static void main(String[] args) {
mostrarNome();
mostrarSobrenome();
}

private static void mostrarSobrenome() {
System.out.print("Sobrenome ");
}

private static void mostrarNome() {
System.out.print("Nome ");
}

}

Alguém resolve fatorá-lo, resolve deixar tudo em um único local.

package exemplo.entidade;

public class Testadora {
public static final int NOME = 10;
public static final int SOBRENOME = 20;

public static void main(String[] args) {
mostrarNome();
mostrarSobrenome();
}

private static void mostrarSobrenome() {
mostrar(SOBRENOME);
}

private static void mostrarNome() {
mostrar(NOME);
}

private static void mostrar(int tipo) {
if (tipo==NOME){
System.out.print("Nome ");
}else if(tipo==SOBRENOME){
System.out.print("Sobrenome ");
}
}

}

A principio parece estar agregando mais complexidade a algo que deveria simplesmente fazer algo trivial. Um terceiro resolve retirar os "mediadores".

package exemplo.entidade;

public class Testadora {
public static final int NOME = 10;
public static final int SOBRENOME = 20;

public static void main(String[] args) {
mostrar(NOME);
mostrar(SOBRENOME);
}

private static void mostrar(int tipo) {
if (tipo==NOME){
System.out.print("Nome ");
}else if(tipo==SOBRENOME){
System.out.print("Sobrenome ");
}
}

}

Um quarto metido a espertinho realiza uma mudança que deixa o código bem mais simpático.

package exemplo.entidade;

public class Testadora {
public static final int NOME = 10;
public static final int SOBRENOME = 20;

public static void main(String[] args) {
mostrar(NOME+SOBRENOME);
mostrar(NOME);
mostrar(SOBRENOME);
}

private static void mostrar(int tipo) {
if (tipo==NOME){
System.out.print("Nome ");
}else if(tipo==SOBRENOME){
System.out.print("Sobrenome ");
}if (tipo==NOME+SOBRENOME){
System.out.print("Nome Sobrenome ");
}
}

}

Fica simples e objetivo o propósito mostrar o nome e o sobrenome. :)

ps: favor notar que o post não discute o fato de usar ou não polimorfismo, apenas mostra um modo elegante de se aproveitar o uso de constantes.

Os altos e baixos da qualidade na conexão 3G!

2008-11-29T04:38:00.000-08:00

Atualmente uso o link da BrT 3G para acessar a Internet. Notei que sempre houve altos e baixos, um dia a conexão está ótima outro está péssima, procurei na Internet e não encontrei nada que me ajudasse, liguei pra BrT e tive a seguinte resposta o "Windows Vista não está listado na blá blá blá blá.. por isso a rede pode apresentar altos e baixos" e a última coisa foi tentar mudar alguns parametros de configuração pra ver se alterava algo na qualidade.

Basicamente só mudei o modo preferencial da rede, pra acessar esse menu tenha certeza que ainda não está conectado na rede, clique em 1,2,3 e 4 note que o 3 (os números são referências pra figura abaixo) permite alterar o modo que a rede é escolhida.

Veja as estatísticas de quando configurei o modem pra "Preferir 3G" (neste modo há uma oscilação entre os vários protocolos : HSDPA, UMTS e EDGE [ao menos os que percebi])

* Quando digo estatísticas me refiro a saída do comando ping www.google.com.br -n 25 que executei em ambiente Windows.

Estatísticas do Ping para 209.85.193.99:
Pacotes: Enviados = 25, Recebidos = 18, Perdidos = 7 (28% de perda),
Aproximar um número redondo de vezes em milissegundos:
Mínimo = 714ms, Máximo = 4140ms, Média = 2017ms

Estatísticas do Ping para 209.85.193.104:
Pacotes: Enviados = 25, Recebidos = 19, Perdidos = 6 (24% de perda),
Aproximar um número redondo de vezes em milissegundos:
Mínimo = 578ms, Máximo = 3849ms, Média = 2697ms

Estatísticas do Ping para 209.85.193.99:
Pacotes: Enviados = 25, Recebidos = 24, Perdidos = 1 (4% de perda),
Aproximar um número redondo de vezes em milissegundos:
Mínimo = 211ms, Máximo = 4195ms, Média = 2318ms

Estatísticas do Ping para 209.85.193.99:
Pacotes: Enviados = 25, Recebidos = 25, Perdidos = 0 (0% de perda),
Aproximar um número redondo de vezes em milissegundos:
Mínimo = 920ms, Máximo = 3914ms, Média = 1890ms

Estatísticas do Ping para 209.85.193.104:
Pacotes: Enviados = 25, Recebidos = 12, Perdidos = 13 (52% de perda),
Aproximar um número redondo de vezes em milissegundos:
Mínimo = 1366ms, Máximo = 4155ms, Média = 2586ms

Estatísticas do Ping para 209.85.193.99:
Pacotes: Enviados = 25, Recebidos = 25, Perdidos = 0 (0% de perda),
Aproximar um número redondo de vezes em milissegundos:
Mínimo = 132ms, Máximo = 3696ms, Média = 1206ms

Usando o modo "Preferir 3G" quando a rede usou o protocolo HSDPA a qualidade da conexão ficou boa.

Estatísticas do Ping para 209.85.193.99:
Pacotes: Enviados = 25, Recebidos = 25, Perdidos = 0 (0% de perda),
Aproximar um número redondo de vezes em milissegundos:
Mínimo = 129ms, Máximo = 156ms, Média = 139ms

Depois que mudei o modo para "Apenas 3G" veja as novas estatísticas.

Estatísticas do Ping para 209.85.193.104:
Pacotes: Enviados = 20, Recebidos = 19, Perdidos = 1 (5% de perda),
Aproximar um número redondo de vezes em milissegundos:
Mínimo = 109ms, Máximo = 332ms, Média = 137ms

Estatísticas do Ping para 209.85.193.104:
Pacotes: Enviados = 20, Recebidos = 20, Perdidos = 0 (0% de perda),
Aproximar um número redondo de vezes em milissegundos:
Mínimo = 121ms, Máximo = 218ms, Média = 142ms

Claramente houve uma melhoria consideravel. Mesmo configurando para "Somente 3G" ainda existe a oscilação entre os protocolos HSDPA e UMTS, sempre que se usa o UMTS a qualidade da conexão é reduzida.

Conversando com alguns técnicos da BrT eles me informaram que em alguns locais o sinal 3G pode ser bem fraco ou inexistente, nesses casos é bom deixar "Preferir 3G". Eu sempre uso o "Somente 3G", até porque eu paguei foi por isso. Minha conexão ficou bem melhor após essas "mudanças", claro que as oscilações continuam mas agora são bem menores.

Jpcsp - Estado (status) atual e alguns screenshots do emulador de psp feito em java

2008-11-12T14:55:00.000-08:00

Para o jogo Tales of Eternia (ToE) o problema de antes (a grid que aparecia na renderização) desapareceu. Novos desenvolvedores que têm ótimas habilidades com opengl somaram mais ao grupo !

Nesse momento estamos trabalhando em algumas otimizações, cacheamento de texturas, melhorando código em partes que são extremamente executadas... e claro sempre "evoluindo", o jpcsp oferece um ótimo debugger além de um sistema de logging que AJUDA muito.

Login - autenticação e autorização usando JavaServer Faces (jsf)

2008-11-03T04:59:00.001-08:00

Este post trará (ou tentará trazer) informações básicas para o desenvolvimento de um sistema de login para aplicações web javaserver faces (jsf) . Com estas informações creio que será possível pra você implementar seu sistema de Login.

Basicamente...

O Usuario tem um nomeDeUsuario uma senha e um ou mais Perfis.

Cada Perfil está vinculado a uma ou mais páginas. (ou recursos ou qualquer nomenclatura que você quiser usar)

Uma Página é um objeto simples que tem uma descrição.

Na tentativa de resumir a estrutura seria algo semelhante a essa pseudo-modelagem...

Pagina paginaAdmin = new Pagina("/admin.jsf");

Pagina paginaNormal= new Pagina("/principal.jsf");

Perfil admin = new Perfil();

admin.temAcesso(paginaAdmin).temAcesso(paginaNormal);

Perfil normal = new Perfil();

normal.temAcesso(paginaNormal);

Usuario homerSimpsons = new Usuario("homer99","senha");

homerSimpsons.temPerfilDe(admin);

Crie um PhaseListener como abaixo.

package meu.pacote.br;
import javax.faces.application.NavigationHandler;
import javax.faces.context.FacesContext;
import javax.faces.event.PhaseEvent;
import javax.faces.event.PhaseId;
import javax.faces.event.PhaseListener;
import javax.servlet.http.HttpSession;

public class AuthorizationListener implements PhaseListener {

public void afterPhase(PhaseEvent event) {
FacesContext facesContext = event.getFacesContext();
//adiquirindo o FacesContext.
String currentPage = facesContext.getViewRoot().getViewId();
//armazenando a página que fez a requisição. (a string da pág. atual ex: "/pag.jsf")
boolean isLoginPage = (currentPage.lastIndexOf("login.xhtml") > -1);
//fazendo a verificação mais básica de todas... se é a página de login.
HttpSession session = (HttpSession) facesContext.getExternalContext().getSession(true);
//adquirindo a sessão (essa mesma onde você deverá guardar seu usuário no nível de sessão com descritor currentUser).
Usuario user = (Usuario) session.getAttribute("currentUser");
//apenas recuperando o valor da sessão.
if (!isLoginPage && user == null) {
NavigationHandler nh = facesContext.getApplication().getNavigationHandler();
nh.handleNavigation(facesContext, null, "loginPage");
//bem, se não está logado redireciona pra lógica que (navigatio rule) atende a loginPage
} else {
//verificar se o usuario atual tem acesso a página atual.
boolean temAcesso = user.temAcesso(new Pagina(currentPage));
if (!temAcesso){
//aqui a logica de não ter acesso... redicione novamente? faça algo... ???
}
}
//caso contrário o jsf passa tranquilamente por aqui!!!

}

public void beforePhase(PhaseEvent event) {
//poderia ter sido escrito nesse evento antes da "fase" (lembra do básico do jsf, o ciclo de vida e as fases...
}

public PhaseId getPhaseId() {
return PhaseId.RESTORE_VIEW;
}
}

E uma lógica pra logar o usuário na sessão...

FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("currentUser", user);

E registre essa classe no arquivo faces-config.xml. Claro, registre também um navigation que atenda a qualquer chamada para loginPage.

<lifecycle>
<phase-listener>
org.gpro.filter.AuthorizationListener
</phase-listener>
</lifecycle>

<navigation-rule>
<from-view-id>/*</from-view-id>
<navigation-case>
<from-outcome>loginPage</from-outcome>
<to-view-id>/login.xhtml</to-view-id>
<redirect/>
</navigation-case>
</navigation-rule>

Claro que o código pode e deve ser modificado para questões de flexibilidade, legibilidade e até mesmo performance. O propósito inicial era mostrar como desenvolver um sistema de login com jsf. O código mostrado foi feito apenas pra exemplificar qualquer erro ou dúvida postem aqui.

Mais informações em:

http://java.sun.com/javaee/javaserverfaces/1.1_01/docs/api/javax/faces/event/PhaseListener.html

Jpcsp - já mostra tela de jogo comercial

2008-11-01T15:33:00.000-07:00

Depois de algum (MUITOOOOOOOO) trabalho veja a primeira screen de um jogo comercial rodando no jpcsp.

Apartidarismo

2008-10-28T20:14:00.000-07:00

Brasil um país democrático! Bonita frase, não?!

Nesse último pleito tive chance de observar, com mais atenção, os vários arquétipos de eleitores. Infelizmente percebi que ainda existem pessoas que não usam a razão pra votar.

É simples. Existem pessoas que votam em determinado candidato em detrimento do seu partido, alguns mais excitados chegam à loucura de afirmar: "Sou XYZ em qualquer pleito". Na frase anterior troque XYZ por DEM ou PP ou PSDB ou PMDB ou PMN ou PSOL ou PT ou PTB ou qualquer outro partido que você conheça.

Por favor, eleitor seja “apartidário”... Isso não é um jogo de futebol no qual você torce por um time, pense que além da sigla existe um ser, então numa mesma bandeira há candidatos bons e ruins. Se você achar que todas as opções atuais não atendem a seus critérios, vote em branco.

Crítico mesmo é ser candidato, eles devem apoiar quem seu partido apóia... (mesmo que no fundo achem um outro mais adequado) mas você não é candidato: Não apóie siglas, não vote por elas!

Nessa transa partidária deixo um último (incisivo e repetitivo) recado: Um partido não é um time de futebol.

Não vote:
Somente por que o candidato XisIpslon está ganhando nas pesquisas.
Por que o XisIpslon é do partido XY.

Frase que odeio ouvir:
"nunca mais voto no PT" (substitua PT por qualquer outro partido)
"em todas as eleições sou PMDB até a morte" (substitua PMDB por qualquer outro partido)
(ATENÇÃO apartidarismo não é antipartidarismo)

Dsl interna e externa: perguntas e respostas por Martin Fowler

2008-10-03T20:52:00.000-07:00

Segue abaixo a traduadaptação [datada em 01/10/2008] (meio capenga) do artigo de Martin Fowler aqui você vê o original.

Fui convidado a criar uma discussão de DSL para não-técnicos. Talvez eu tenha lido muito Stephen O'Grady, mas senti um desejo irresistível de fazê-lo do jeito Q e A (Perguntas e Respostas). Então vamos lá.

O que é uma Domain Specific Language? (ou linguagem de domínio especifico, ou ainda DSL)

Uma Domain Specific Language (DSL) é uma linguagem de programação de expressividade limitada, focada num domínio particular. A maioria das linguagens que você conhece são linguagens de propósito geral (General Purpose Languages), que podem lhe dar com a maioria das coisas que você encontra durante um projeto de sistema. Cada DSL pode agir somente em um aspecto especifico do sistema.

Então você não poderia escrever todo projeto em uma DSL?

Não. A maioria dos projetos irão usar uma linguagem de propósito geral e muitas DSL's.

Essa idéia é nova?

Não totalmente. DSL's tem sido usadas extensamente nos círculos de usuários do Unix desde os primórdios desse sistema. A comunidade Lisp discute a criação de DSL's em Lisp e então usa a DSL para implementar a lógica. A maioria dos projetos de TI usam muitas DSL's – você já deve ter ouvido de coisas como CSS, SQL, expressão regular e etc.

Então porque este assunto está fazendo tanto barulho só agora?

Provavelmente é por causa do Ruby and Rails. Ruby é uma linguagem com muitas características que tornam fácil o desenvolvimento de DSL's e as pessoas que estão envolvidas na comunidade Ruby têm se sentido mais a vontades com essa abordagem, então eles levam vantagem dessas características. Em particular o Rails usa muitas DSL's que o deixam mais fácil de usar. Isto, por sua vez, tem incentivado mais pessoas a seguir essas idéias.

Outra razão é que muitos sistemas feitos em Java ou C# precisam ter muito de seu comportamento definido de forma mais dinâmica. Isto conduziu a arquivos XML complexos que são difíceis de compreender que, por sua vez, levou as pessoas a explorar DSL's novamente.

Então DSL's podem ser usadas com outras linguagens além do Ruby?

Sim, como eu já disse, as DSL's já estavam por ai há muito tempo, mais do que o Ruby. Ruby tem uma sintaxe não obstrutiva e também características de meta-programação que a torna mais fácil para criar elegantes DSL's internas, mais do que outras linguagens como C# e Java. Mas existe DSL's internas uteis feitas em Java e C#

Qual a diferença entre DSL interna e DSL externa?

Uma DSL interna é apenas um idioma particular de escrever código na linguagem hospedeira. Então uma DSL interna feita em Ruby é um código Ruby, escrito num estilo particular que deixa a linguagem mais próxima da linguagem hospede. Tais como elas podem ser chamadas de Interface Fluente ou DSL embutida. Uma DSL externa é uma linguagem completamente separada que é "traduzida" para que a linguagem hospedeira possa entender.

Por que as pessoas estão interessadas nas DSL's?

Eu vejo que as DSL's possuem dois principais benefícios. O benefício mais comum é fazer que certos tipos de códigos fiquem mais fáceis de compreender, que se tornem mais fáceis de modificar, assim melhorando a produtividade do programador. Isto é válido para todos interessados e relativamente fácil de atingir. O benefício mais interessante, todavia, é que uma DSL bem projetada pode ser entendível por pessoas do negocio, permitindo-lhes compreender diretamente o código que implementa suas regras de negócios.

Então este é o gancho – pessoas do negócio escrevendo suas próprias regras?

Em geral eu não penso assim. É muito trabalhoso criar um ambiente que permita as pessoas do negocio escrever suas próprias regras. Você tem que fazer boas ferramentas de edição, depuração, testes e etc. Você tem a maioria dos benefícios das DSL's apenas permitindo que pessoas do negocio sejam capazes de ler as regras. Então eles podem revê-las para aperfeiçoa-las, falar sobre elas com os desenvolvedores e propor mudanças corretas da implementação. Ter DSL's legíveis ao contexto negócios é de longe menos esforço do que ter DSL's escrevíveis pelas pessoas do negócios, mas os ganhos ainda são bons. Existem momentos onde vale a pena o esforço para fazer DSL's escrevíveis por pessoas do negocio, mas esse é um objetivo mais avançado.

Você precisa de ferramentas especiais (leia-se caras)?

Normalmente, não. DSL's internas são apenas facilidades da linguagem de programação que você está usando. DSL's externas requerem que você use algumas ferramentas especiais – mas essas são open source e muito maduras. O maior problema com essas ferramentas é que a maioria dos desenvolvedores não estão acostumados com elas e acreditam que elas são complicadas de usar mais do que elas realmente são (um problema exacerbado pela pobre documentação).

Todavia há exceções no horizonte. Existe uma classe de ferramentas que eu chamo LanguageWorkbench. Essas ferramentas permitem você definir DSL's mais facilmente e também provem sofisticados editores para elas. Ferramentas assim tornam mais viáveis a construção de DSL para os negócios.

Então isto é a repetição do sonho do desenvolvimento de software sem programação (ou programadores)?

Esta foi a intenção do COBOL e não penso que há alguma razão para que as DSL's tenham sucesso onde o COBOL (e tantas outras falharam). Eu penso que é importante que DSL's permitam pessoas do negocio e desenvolvedores colaborarem mais eficientemente porque eles podem falar sobre um conjunto de regras que também são códigos executáveis.

Quando eu deveria considerar a hipótese de criar uma DSL?

Quando você está trabalhando num aspecto do sistema com ricas regras de negócios ou work-flows. Uma DSL bem escrita deveria permitir que os clientes entendessem as regras pelas quais o sistema funciona.

Isto não vai levar a uma cacofonia de linguagens que as pessoas acharam mais difíceis de aprender?

Nós já temos uma cacofonia de frameworks que os programadores tem que aprender. Isto é uma inevitável conseqüência de sistemas reusáveis, é o único jeito que temos de lhe dar com todas essas coisas que os sistemas tem que fazer hoje em dia. Na essência uma DSL não é nada mais do que uma fachada chique sobre um framework. Como resultado elas contribuem um pouquinho com a complexidade que já havia. Na verdade uma boa DSL deveria fazer as coisas melhores tornando esses frameworks mais fáceis de usar.

Mas as pessoas não vão criar muitas DSL's de baixa qualidade?

Claro, assim como pessoas criam frameworks de baixa qualidade. Mas, novamente, eu gostaria de argumentar que DSL's de baixa qualidade não causam mais danos se comparados aos que os frameworks mal projetados causam

Bons modos pra desenvolvedores

2008-09-30T10:34:00.001-07:00

ótimo texto que "enumera" várias ideias ótimas, LEITURA OBRIGATÓRIA!

http://www.infoq.com/articles/API-Design-Joshua-Bloch

DSL o que é? qual a diferença entre dsl interna e dsl externa? quando deveria criar uma dsl? ... etc.

2008-09-25T07:20:00.001-07:00

Para maiores esclarecimentos sobre o assunto DSL, de acordo com a opinião do Martin Fowler.
http://www.martinfowler.com/bliki/DslQandA.html e uma versão traduzida aqui
http://archsofty.blogspot.com/2008/10/dsl-interna-e-externa-perguntas-e.html.

Perguntas como:
O que é uma Domain Specific Language? (ou DSL)
Dsl podem ser usadas e criadas por outras linguagens sem ser Ruby?
Qual a diferença entre DSL interna e DSL externa?
Porque as pessoas estão interessadas no assunto DSL?
É necessário alguma ferramenta especial ou cara pra desenvolver DSL?
Quando deveria criar uma DSL?

São respondidas no link acima.

Não existe uma resposta definitiva, há caminhos pra solução...

2008-09-24T07:53:00.001-07:00

Quando visitamos foruns pela Internet (sobre desenvolvimento) notamos que as pessoas estão mais preocupas em saber o que fazer? qual padrão usar? qual sigla colocar na documentação do projeto? como ser ágil com post-it? e pouquíssimas procurando o pôrque de fazer isso tudo...
O modismo não pará por aí, quando surge uma nova "buzzword" o pessoal já cria n consultorias, treinamentos online... exploram de todas as formas pra tentar faturar uns dollars.
Por isso, desde o inicio dos tempos, cautela nunca é pouco. (mas por favor também não seja um Adrian Monk)

Configurar proxy pelo código no Java

2008-09-24T05:48:00.001-07:00

Pra quem já passou algum tempo tentando se conectar a algum sítio na Internet passando a conexão pelo proxy... aqui vai uma diquinha (besta, a proposito)

            Properties systemSettings = System.getProperties();
            systemSettings.put("http.proxyHost", "10.10.10.10");
            systemSettings.put("http.proxyPort", "8784");

            Authenticator.setDefault(new Authenticator() {
                protected PasswordAuthentication getPasswordAuthentication() {
                    return new PasswordAuthentication("dominio\\usuario", "senha".toCharArray());
                }
            });

                URL u = new URL("http://www.foo.com.br");
                HttpURLConnection con = (HttpURLConnection) u.openConnection();
                con.connect();
Simples assim.

Screenshots e atual status do emulador de psp feito em java o Jpcsp

2008-09-23T18:49:00.000-07:00

O desenvolvimento já está em estágio onde gráficos 3D são "plotados" na tela. Vários demos e os exemplos do nehe tutorial (sobre OpenGL) já funcionam.

"As imagens falam melhor"
A versão atual (0.08) conta com um time de desenvolvedores com grande fama no mundo da emulação. (claro que excluindo-me)

Com um recompilador (ainda em testes)

A entrada (o controle) já está emulada também.

Que ironia, o emulador de NES (8 Bits) rodando no emulador de PSP sobre uma máquina Virtual (JVM), haja indereção...

O Famoso Solitaire

Aqui em um ambiente 3D já está suportando efeito de reflexo

Mais do núcleo 3D

E pra terminar, para aqueles que amam um bom debugger;
Como diz o Taz: Olha isso!

ps: O número de FPS está baixo pois estou usando uma máquina single core e com uma placa de vídeo ruim. Em máquinas melhores os quadros sobem de 10FPS a 15FPS.

Futurama inspires me (000001)

2008-09-14T19:16:00.000-07:00

"Which is the default port to make love?"
"In the future the O.S. will run inside us, and then we don’t deserve Linux or Windows but ChorusOS."
"What excites me isn’t the beautiful but the sensuality... and that's was the reason what I’ve choose the robot Sen5U@l1ty"

Inteligência e otimização direto no compilador Java javac

2008-08-30T08:28:00.000-07:00

Java há muito tempo não é vista como uma plataforma computacional lenta. Parte da "nova rapidez" foi conseguida através da evolução do interpretador e do compilador java.
Os esforços e as características contidas no núcleo do interpretador e do compilador (java.exe e javac.exe), a cada nova versão, na maioria das vezes não é visto pelo desenvolvedor.

Vou apresentar um exemplo interessante (ao menos eu achei :D ):
A seguinte classe implementa a idéia da execução de um código de máquina...

public class Cpu6502{
private final static boolean isDebug = true;

public void execute(){
while(true){
int opcode = memoria[PC++];
switch (opcode){
case NOP:
log("nop executado");
break;
case ANDI:
log("and immediate executado");
...
case default:
log("opcode não suportado " + opcode);
break;
}

}

System.out.println("Fim");
}

private void log(String msg){
if (isDebug) System.out.println("6502 Debug > " + msg);
}
}

Até agora nada de novo, é necessário saber quais opcodes ainda não estão implementados ... mas e quando quisermos "tirar o pesso da saída padrão"? Basicamente é só mudar o valor do campo isDebug pra false. Ainda nenhuma novidade!!!

Realmente não há nenhuma novidade visível, veja o que o compilador javac faz quando compilamos a classe com o campo isDebug = false: (pra decompilar usei o Jode)

public class Cpu6502{
private final static boolean isDebug = false;

public void execute(){
while(true){
int opcode = memoria[PC++];
switch (opcode){
case NOP:
log("nop executado");
break;
case ANDI:
log("and immediate executado");
...
case default:
log("opcode não suportado " + opcode);
break;
}

}

System.out.println("Fim");
}

private void log(String msg){

}
}

O compilador viu que esse código nunca seria executado, dado as características do campo isDebug=false(final), então o compilador retira esse bloco... Esperto esse javac não!?
Só pra finalizar, acredito que o java.exe vê que o bloco não faz nada e simplesmente ignora-o. Esses são aqueles tipos de maravilhas invisíveis ao olho do desenvolvedor.

ps: Isso pra não citar o HotSpot... simplesmente fantástico!

Jpcsp - um emulador de psp feito em java

2008-08-19T18:35:00.000-07:00

Depois de muito tempo sem postar nada, volto com uma notícia (in)útil: apos tanto admirar e estudar o mundo da emulação, resolvi participar ativamente de um projeto (opensource claro :) ) desses.

Nesse projeto estamos tentando emular um psp (uma máquina portatil da sony muito interessante, com hardware bem similar ao Playstation 2) usando Java como linguagem e OpenGl (JOGL) como nosso motor renderizador. A escolha dessas tecnologias visa um emulador multiplataforma e também um desafio.

O Psp é uma máquina que possui um processaor (RISC) MIPS baseado no R4000 (32-bits), também possui um GPU com 2MB de VRAM: O CPU roda a 222MHz (apesar de ir até 333MHz, por questões de economia de consumo a sony "clocou-o" de 0 a 222Mhz inicialmente, todavia em novas versões do firmware é possível rodar jogos a 333Mhz) e a GPU roda a 166Mhz. Tem 32MB de Ram, algumas versões novas do psp já vem com 64MB, enfim é se trata de um aparelho muito interessante.

O projeto atualmente está rodando algumas demos e o time de desenvolvedores estão integrando código (commit) praticamente todos os dias, a velocidade de desenvolvimento está ótima. Pra quem deseja conhecer mais sobre o projeto há os links abaixo.

Links.
Site Oficial: http://www.jpcsp.org/
Forum oficial: http://jpcsp.org/forum/
Repositório: http://code.google.com/p/jpcsp/source/list

Artigo sobre dsl interna publicado na mundo java

2008-07-17T04:53:00.000-07:00

Nesta última edição (30) da revista Mundo Java foi publicado um artigo que escrevi sobre dsl interna em java. O mesmo foi publicado na sessão Mundo OO.
Toda crítica é bem-vinda! :)

Pra quem for comprar a capa é essa.

Mundo OO: Implementando uma dsl Interna
Projetando e codificando uma domain-specific language interna usando a linguagem Java.

o primeiro emulador do console nintendo wii já da alguns passos

2008-07-16T05:58:00.000-07:00

O primeiro rascunho de emulador dos consoles da 7º geração de video-games já está sendo desenvolvido. Melhor notícia que essa talvez seja que, tanto a 6º quanto 7º geração da Nintendo estarão em um único emulador, ou seja, dentro de alguns anos você poderá jogar jogos do Game Cube e Wii no mesmo emulador.

Tanto Game Cube quanto o Wii tem arquitetura PowerPC (IBM), além de outras similaridades (como GPU da ATI...), o que contribuiu para que a equipe que já desenvolvia o emulador do Game Cube começasse um projeto para o Wii.

Pra rodar, satisfatoriamente, esse emulador é necessário ter uma máquina de gamer. O emulador oferece dois modos pra emulação do processador, interpretação dos opcodes (lenta) ou recompilação dinâmica (bem mais rápida), a DynaRec requer processadores com aquele conjunto de instruções SSE2 (note que no repositório já se fala do uso até mesmo do récem SSE4 [ Core2Duo e8400 possui, não conheço nenhum AMD que tenha :( ]), claro que uma GPU ("placa de vídeo") de ótima performance também é necessária. Se tentar rodar o emulador em uma máquina média terá algumas decepções.

A pergunta que fica provavelmente é como emular ou adaptar o Wii Remote ( e seus Acelerómetros) para PC?!
Bem acredito que isso será contornado, problema maior será o próprio console mas é muito cedo pra qualquer afirmação, apenas dúvidas nesse momento são certas.

Veja algumas screens

Game Cube - Super Mario Sunshine(17-36 FPS)

Game Cube - Zelda Wind Waker

Wii - Sega Superstars Tennis

Links:

Repositório
svn

Mais Screenshots (inclusive de algums jogos do wii)
Aqui

Feedback, dê suas sugestões técnicas
Issue List

ATENÇÃO: você só pode jogar legalmente uma rom (iso ou dump do seu jogo) se possuir a original.
ATENÇÃO: o emulador está em desenvolvimento, mostrará melhores taxas de FPS e correções de bug com passar do tempo, não é tão estavel quando um do super nintendo.
ATENÇÃO: quase todas as marcas, produtos e idéias são de propriedade da Nintendo.

Siglas 3 letras - MDA MDD DDD DSL TDD xxx ??? yyy

2008-07-15T05:40:00.000-07:00

Maior vocabulário ou vocabulário mais pobre?!
Tente "advinhar" quantas siglas você conhece (só no que tange o desenvolvimento de software) com três letras... chute um número! Tenho certeza que errou.
Siglas são mais fáceis de serem usadas pra criar um vocabulário, claro que o excesso delas também pode gerar um vocabulário pobre.

Conhecemos bem mais siglas do que imaginamos...
Pense bem qual a quantidade (real) de siglas com três letras você conhece: jcp, jsp, asp, php, orm, jpa, jsf, dsl, cvs, svn, ejb, sql, ddd, soa, aop, tdd, .net, uml, oop, cpu... enfim, isso sim é um vocabulário próprio, que pode ajudar a comunicação ou criar modismos ou vender consultorias e por ai vai..
ps: isso sem contar todas as extensões de arquivos que acostumamos a usar no dia-a-dia (doc, txt, exe...)

Take care
O cuidado fica para o uso correto das siglas. Por favor, tente usar só siglas que realmente você conhece. Evitar modismos é necessário, ser até mesmo chato com uma nova sigla (ou tecnolgia, framework, metodologia, processo...) que surge, não aceitando-a facilmente.
Uma das maiores bagunças, atuais, pra mim é a correta definição e uso do desenvolvimento guiado (orientado|voltado) aos modelos. Tem gente que acha que isso e ferramenta case é tudo igual outros dizem que a idéia original (e problemas) persistem...

Boas referências! (boas nada, ótimas mesmo)
Um ótimo artigo pra ler...uma visão "crítica" sobre os atuais modismos e usos [in]adequados para desenvolvimento orientado por modelos Model Driven Software Developement
Outro artigo crítico e bom é o artigo Empresa Três Letrinhas do Phillip Calçado (P. Shoes)

Subversion 1.5 já liberado ( svn 1.5 )

2008-06-24T05:02:00.000-07:00

Tanto clientes como servidores deverão ser atualizados, porém pode-se atualizar o servidor ... depois o cliente....
Funciona com repositorios antigos, alias você DEVE executar o upgrade command, para que os repositórios antigos entrem no novo formato.
Para quem deseja conhecer as "melhorias" veja...
Notas do lançamento.

As atribuições de um arquiteto de software

2008-05-29T05:57:00.000-07:00

Na última edição da revista The Architecture Journal ,de número 15, foi tratado quais são as atribuições de um arquiteto de software, o pôrque de um arquiteto, quais habilidades são requiridas e etc. A edição ainda traz, como de costume, o perfil de um arquiteto para ser analisado.
Gostei da edição porque simplesmente há vários pontos de vista sobre "essa" profissão, há esclarecimentos sobre o que faz, qual a necessidade de conhecimento técnico. Enfim são várias opiniões sobre o mesmo assunto com diferentes pontos de vista.

Resumo.

* Foreword
* We Don’t Need No Architects
* Becoming an Architect in a System Integrator
* Architecture Journal Profile: Paul Preiss
* The Open Group’s Architect Certification Programs
* The Need for an Architectural Body of Knowledge
* A Study of Architect Roles by IASA Sweden
* The Softer Side of the Architect
* An A-Z Guide to Being an Architect

Para essa edição (15 - The Role of an Architect)
Acesse o site aqui. (já adianto que não é sobre como usar tecnologias (nem .net nem java))

Mais do mesmo

2008-05-21T07:08:00.000-07:00

Depois de ler + um ótimo post .
Darei mais alguns exemplos que já vivenciei:
lógica para somar pontos a clientes...

cliente.setPontos(cliente.getPontos()+1);
(e isso se espalhava por todo código...)
Se alguma data do ano (especial, comemorativa, aniversário da loja...) quisesem oferecer uma promoção de a cada compra o cliente aumentaria os pontos em 10 seria MUITO chato...

Mais simples
cliente.adicionarPontos();
Se houvesse alguma mudança bastaria fazê-la no método.

Ou ainda quantas vezes vi algo semelhante...

if (funcionario.getSalario() > 1000.0d){
funcionario.setAjuste(0.03d);
//além do fato do pessímo uso dos double, float para $
}

Um comportamento que deveria ser interno ao "objeto" funcionário sendo tratado em outro local, talvez melhor seria algo como... (o próprio método do funcionário conter essa "lógica")

public double getAjust(){
if (getSalario()>1000.d){
setAjuste(0.03d);
}
}

ps: acredito que tudo visa um final menos complexo.(final = manutenção) Centralizar os comportamentos nos objetos...

JPA em ambiente de produção (I)

2008-04-30T06:27:00.000-07:00

Algo interessante a se notar é que algumas configurações podem ajudar a reduzir o impacto do uso de um framework ORM/persistência...
Por exemplo, "algumas" implementações do JPA oferecem a possibilidade de que o próprio framework crie, atualize e delete o esquema de tabelas, todavia esse tipo de recurso pode ser não desejável em ambientes de produção.

Veja o exemplo da implementação hibernate:
propriedade hibernate.hbm2ddl.auto
"Automatically validate or export schema DDL to the database when the SessionFactory is created. With create-drop, the database schema will be dropped when the SessionFactory is closed explicitly."

Ou seja, toda primeira vez que criarmos uma "session factory" [no caso EntityManagerFactory do JPA] o framwork vai tentar criar, validar ou etc. mesmo que o banco com as tabelas já existam. Pra quem dúvida basta observar o console, irá notar que o jpa tentar criar com ddl todo o esquema.

Outro caso é a implementação toplink:
propriedade toplink.ddl-generation ...

Enfim é interessante desligar essas opções em produção, aproveitar para deixar livre para outras coisas como logger...

Testes unitários são criados para serem usados

2008-04-29T05:54:00.000-07:00

É incrível ver pessoas escrevendo testes unitários apenas pra dizer que testam, não os usam realmente.
Um dos reais benefícios dos testes está em como um bom conjunto de testes pode ajudar em manutenções futuras do software, é necessário guardar esse conjunto de testes.A cada manutenção no software você pode rodar TODOS os testes (não só os novos que você fez... pra essa nova característica) e notar se houve alguma mudança em outras partes do código, não pense que sempre uma pequena mudança não irá afetar outras.
Alias não pense ou ache, teste!

Testes podem ajudar mais do que parece.
Faça, use, guarde e reuse seus testes.

dsl externa - como uma especificação pode te ajudar a compreender-las

2008-04-25T23:08:00.000-07:00

Procurando ajuda sobre uma especificidade do java, encontrei a seguinte referência: The Java Language Specification, Third Edition

Neste "livro", sobre a especificação do java, há dois capítulos interessantíssimos para quem está interessado em dsl. Os capítulos são:
Grammars
Lexical
Para se desenvolver uma mini linguagem de um domínio especifico (dsl) é importante conhecer conceitos sobre como criar-la e como as coisas funcionam. (não é necessário nem citar que conhecer o domínio em questão é IMPRESCINDÍVEL ou mesmo criar uma "linguagem" comum entre desenvolvedores e experts do domínio [ubiquitous language])
Nestes capítulos há bons textos que explicam sobre o desenvolvimento de uma sintaxe, palavras chaves, totens e outros aspectos interessantes. Com toda certeza os capitulos não irão cobrir todo o assunto, falta vários outros aspectos como "compilação"... mas acredito que os mesmos possam ajudar.

PS: perdão pelo título (nada criativo).

Sistemas são todos iguais... (até onde vai o reuso)

2008-04-01T06:36:00.000-07:00

Fale-se sempre de domínio (especifico) para cada sistema... Também é bem dito que do domínio se aproveita pouco ou nada, aproveitamos mais de camadas de infraestrutura.

Mesmo assim "há grupos de pessoas" que insistem em vender um portal (sistema) que serve pra toda situação, ou seja, o portal da Globo.com pode ser também o portal da Gamespot.com, mesmo que portais (ou qualquer "coisa") tenham conceitos similares, um mesmo conceito de notícia para um portal pode ser totalmente diferente de outro, talvez pode até marcar o sucesso de um portal a visão desse "conceito" voltado aquele domínio especifico.

As empresas que compram esses portais "gerais" sempre recaem em se adaptar para usufruir do bem adquirido. Mais ou menos assim, "o cliente deve moldar seu negócio para que o mesmo caiba no sistema."

Comprei uma placa de vídeo de uma empresa (xfxforce.com), a placa de vídeo não oferece o controle de velocidade da ventoinha (fazendo um barulho ensurdecedor), logo pensei: "- Entrarei no site e vou mandar um email enfim tentar um contato para saber o que posso fazer."

Tive uma ótima surpresa, a empresa XFX oferece um sistema de suporte que agiliza e muito o processo de suporte dessa empresa (domínio especifico) funciona mais ou menos assim:

Todo produto que compra deles tem um número serial.
Logo você se cadastra no site e cadastra seu produto.
(não preciso descrever o que comprei apenas coloco o serial)
Bem depois de registrado o produto posso abrir um ticket para suporte.
Esse tal ticket funciona como um bilhete no qual você escreve sua dúvida/reclamação/sugestão para um técnico da XFX.
Assim o ticket fica em estado de "Com o técnico".
Tão logo o técnico responder ao ticket, o sistema envia um email avisando...
O ticket fica em estado "Com cliente"... e assim vai até resolver o problema.

Obviamente há mais recursos, mas o ponto aqui é este sistema funciona muito bem para o negocio da XFX (domínio especifico). Talvez se uma outra empresa quisesse criar um sistema para suporte online poderia com certeza aproveitar as idéias do sistema da XFX todavia não teria muito sucesso se usasse o mesmo sistema completamente.

As vezes o reaproveitamento das idéias juntamente com o entendimento do domínio especifico podem transformar um sistema (mcdonald) em algo com muita qualidade voltado realmente a resolver "aquele problema" não "o problema" de todos [lembra um pouco de arquitetura de referência] , que merece até mesmo citações como essa...

Nomes são importantes

2008-02-27T04:37:00.000-08:00

Lendo o post do Fabio Kung [aqui] achei muito interessante a maneira como ele conseguiu mostrar onde os repositórios (do modo DDD de se desenvolver sistemas) se encaixam e porque usá-los.
As vezes explicar o porquê de se usar um repositório se parece com a explicação (a algum iniciado na tecnologia oo) do porquê de tanta indireção nos sistemas "oo".

O primeiro mashup agente nunca esquece...

2008-02-20T06:57:00.000-08:00

Um mashup é um website ou uma aplicação web que usa conteúdo de mais de uma fonte para criar um novo serviço completo.

Definição da wikipédia.

Há alguns anos estava trabalhando num sistema web um "quase-portal", no projeto foi me pedido para que oferecesse um "atalho" para o email corporativo (na época hospedado numa empresa terceirizada). Foi ali que compus meu primeiro mashup tive que me virar para aproveitar o serviço (já pago) d'outro site no "quase-portal", foi algo simples naquele momento tenho certeza que nem tinha idéia do que havia feito.

Entrevista com Refraction, codificador do projeto PCSX2 - um emulador do Playstation 2.

2008-02-19T10:01:00.000-08:00

Se há um grande projeto do qual posso afirmar que complexidade é o ponto alto, é o PCSX2, um emulador da famosa máquina Playstation 2.
Esse projeto conta com um time de desenvolvedores que entre outras várias coisas constroem software de maneira ágil.
Fiz a entrevista com Alex (conhecido como Refraction) e tive várias boas surpresas, por exemplo, eles usam visual studio 2005, tratam o projeto como um hobby não um trabalho... enfim melhor ler pra entender.

Entrevista traduzida:

Leandro:Primeiro qual o seu nome, onde você mora, alias conte-nos um pouco da sua história no desenvolvimento de software?
Alex: Meu nome é Alex, moro em Plymouth, Inglatera, desenvolvimento de software pra mim sempre foi um hobby, comecei com Visual Basic no ano de 2000, logo entre 2002 e 2003 eu fiz meu primeiro emulador (bom e velho *chip8!) usando a linguagem C, cuja tinha mexido um pouquinho pouco tempo antes, eu então passei para a bagunça que é a emulação do GameBoy, isso foi um gancho para trabalhar no time do PCSX2, comecei ajudando bem pouco, então Saqib (formalmente conhecido asadr) perguntou-me se queria juntar-se ao time, ai eu fui pra lá.

Leandro:Como nasceu o time do PCSX2?
Alex: PCSX2 foi criado pelos desenvolvedores do PCSX, Linuzappz e Shadow. Eles tinham terminado com muita acurácia a emulação do PS1 e descobriram o que o próximo passo lógico era dar gás a emulação do PS2, então o PCSX2 nasceu.

Leandro:O time de desenvolvimento é bem integrado?
Alex: Não tanto, o que você quis dizer com integrado, perto um do outro? na amizade sim, mas não tão perto perto perto. Embora nos continuemos bem.

Leandro:Que ferramentas vocês utilizam neste projeto?
Alex: Usamos sourceforge SVN e Visual Studio 2005. Alguns plugins, uso da **SDL, DirectX e OpenGL pra fazer o que for necessário para obter sucesso.

Leandro:O time de desenvolvedores segue algum padrão que vocês estabeleceram?
Alex: Nós não seguimos padrão nenhum, até porque isto é um hobby não um trabalho :)

Leandro:Há algum desenvolvedor responsável por coordenar as ações/atividades do projeto?
Alex: Não ia durar muito coordenando, às vezes dizemos "larga de ser preguiçoso e faça algum código" mas isto quase não é feito :p

Leandro:Vocês tem metas atribuídas por alguém ou apenas o desejo de construir bom software?
Alex: Definitivamente o desejo de construir bom software. Ultimamente o objetivo é ter uma boa emulação do PS2, mas isso é o jeito que as coisas vão.

Leandro:Qual é o melhor e o pior aprendizado que você pode ter no projeto?
Alex: Você quer dizer no projeto? Hmm, eu suponho que seria o ***timming do PS2, isto é dor além palavras.

Leandro:Você conhece algum dos membros pessoalmente?
Alex: Eu conheço dois dos meus testadores beta, CKemu e General Plot, eu conheci ambos.

Leandro:Que tipo de mecanismos vocês usam para se comunicarem?
Alex: Normalmente MSN e IRC, embora IRC tende ser menos sério.

Leandro:Qual recado você pode deixar para os usuários ansiosos?
Alex: Hmmm, no momento as coisas estão paradas, tudo que posso dizer é que em breve os usuários não precisarão ficar tristes por não possuírem o console, esperançosamente iremos ter uma alternativa grátis pra vocês, mas eu não tenho a data exata deste momento:)

Leandro:O cara Brasileiro no projeto (GoldenFinger) está ativo?
Alex: Não atualmente, ele até falou de uma volta, ele está inativo por anos, acredito que ele está ocupado no momento :)

Thanks
Refraction

*chip8 = uma máquina bem simples, que tem como forma de interação um teclado numérico, bem conhecida porque quem começa a desenvolver emuladores.
**SDL = Uma API cross-platform para escrever jogos ou tratar multimídia.
*** Timming = é clock interno (que também deve ser emulado) da máquina PS2.

Impressões:
Incrível como um software tão complexo pode ser construído por pessoas que estão geograficamente distantes. Só como ressalva o PCSX2 em processadores dual core (seja X2 (AMD), ou duo (Intel)) já está rodando em média de 20 a 50 fps.

Links interessantes:
Página oficial
Código fonte
Blog oficial
Forum oficial
Página de downloads
Beta releases
SVN Browser

A entrevista original:

Leandro:First what is you name, where you live actualy, btw tell us a bit of your history on computer software?
Alex: my name is Alex, i live in Plymouth, England, software development for me has always been a hobby, i started with VB back in 2000 and meddled in little bits here and there, then in 2002-2003 time i made my first emulator (good old chip8!) in C, which id picked up merely a few months before hand, i then went on to mess with Gameboy emulation then got hooked on the PCSX2 Team's work, i began helping out on bits, then Saqib (formally known as asadr) asked me to join the team, it went from there.

Leandro:How was born the PCSX2 team?
Alex: PCSX2 was created by the developers of PCSX, Linuzappz and Shadow. They had pretty much finished accurate PS1 emulation and figured the logical next step to fuel their coding needs would be to move on to PS2 emulation, so PCSX2 was born.

Leandro:The development team is quite integreted?
Alex: Not quite sure what you mean here, do you mean "close"? in a friend sort of way yes, but not close close. We get along fine though.

Leandro:Which tools you use on this project?
Alex: We use sourceforge SVN and Visual Studio 2005. some plugins use SDL, DirectX and OpenGL to do what they need to succeed.

Leandro:All the team follow some pattern that you stabelished?
Alex: We dont really follow any pattern, after all it is a hobby, not a job :)

Leandro:Some of the developers are responsible for coordinating the actions / activities of the project?
Alex: Not much coordinating goes on, sometimes we go "stop being lazy and do some coding" but thats as far as it goes :p

Leandro:You have targets set by someone or just the desire to build the good software?
Alex: definately the desire to build good software. Ultimately the goal is to have good PS2 emulation, but thats a way off yet.

Leandro:What is the best and the worst learning you could retrive from the project?
Alex: Do you mean part of the project? hmm, i suppose it would be the timing of the PS2 system, its a pain beyond words.

Leandro:Do you know some member personality?
Alex: I know 2 of my beta testers personally, CKemu and General Plot, i have met them both.

Leandro:What kind of mechanism you use to comunicate between members?
Alex: usually MSN and IRC, although IRC tends to be less serious.

Leandro:What scrap you can tell for anxious users?
Alex: Hmmm, at the moment things are a little dry, all i can say is hopefully soon users wont need to worry about not owning the console, hopefully we will have a free alternative for you, but i have no dates of completion :)

Leandro:The Brazilian guy on project (GoldenFinger) is active?
Alex: Not currently, hes talked about comming back as he was inactive for a few years, but i think hes a bit busy at the moment :)

Thanks
Refraction

Práticas comuns em construção de sistemas

2008-02-14T05:24:00.000-08:00

Introdução

Há uma prática difundida em projetos de software no mundo todo, o uso de diversos ambientes para a construção de sistemas. Em resumo funciona assim, o sistema é construído num *Ambiente de Desenvolvimento*, passa para um *Ambiente de Homologação* e finalmente vai pra *Produção*.
Um ambiente pode ser entendido como um local físico no computador (uma pasta ou computador) mais um conjunto de softwares auxiliares para execução do produto(software). Nesse ambiente é que fica os aplicativos necessários para que aplicação seja executada. Por exemplo: um projeto web feito em asp, normalmente utiliza os seguinte aplicativos: o servidor web IIS, um SGBD qualquer e os arquivos .asp; num projeto web para Java necessita de um container web, um SGBD, a JVM e os códigos(.class, .jsp). O importante é notar que estes aplicativos devem estar em todos ambientes e com as mesmas versões, para que o desenvolvimento seja eficaz, executável e testável em todos ambientes. A replicação de estrutura entre os ambientes.

Ambiente de Desenvolvimento

Quando se desenvolve (código mesmo) ou dá manutenção nas aplicações de uma empresa usa-se o ambiente de desenvolvimento. Nesse ambiente é que fica o código em desenvolvimento que pode ser testado também, ou seja, gerá código executável (não exe, mas no sentido de código funcional).
Existem vários elementos que fazem parte desse ambiente um deles é o...

Source Code Control: São ferramentas que agilizam o processo de unificar o local onde os códigos ficam, os mais conhecidos são: CVS, SVN e Source Control (MS).

E neste ambiente que os *diversos desenvolvedores constroem o código* e "comitam" ( o ato de jogar o código no servidor de código ) e testam. Obviamente a ferramenta mais utilizada neste local é um IDE (VS2008, Eclipse, Netbeans, DephiSuite ...) e o sistema de versionamento de códigos.

Ambiente de Homologação

O sistema vem pra esse ambiente quando já o mesmo já foi produzido e testado no ambiente de desenvolvimento. Esse ambiente pode ser entendido como *ambiente de testes finais*, antes de ir para o usuário gestor do sistema.
É comum neste ambiente *encontrar falhas*, criar um lista com check-list sobre os erros encontrados e repassar-los aos desenvolvedores, para *fix* (outro termo usado para designar o conserto de alguma falha).
O importante é notar que neste ambiente é *ótimo se os testadores forem externos ao desenvolvimento*, ou seja, outra equipe mesmo irá homologar (o ato de certificar que o software está bom para ir para prateleira) o software, usar a mesma pessoa que desenvolve para homologar pode induzir a falhas terríveis.
Algumas empresas de código fechado, neste ambiente não há como ver o código fonte.

Produção

Aqui o produto já está na mão do usuário final, já está em uso oficial, importante notar aqui se todos os comentários de DEBUG foram limpados do código, se todos os dados fictícios de testes foram removidos, se as senhas para acesso ao SGBD foram trocadas, enfim *aqui é sistema final*.

Versões e nomenclaturas

Quando estamos a procura de um software nos preocupamos com várias coisas como qualidade, quem produziu se o mesmo é grátis, de código fonte, pago...
Muitas vezes nos deparamos com produtos com alguns sufixos como M, B, RV, RC...
Para o entendimento dessas diversas siglas utilizaremos um exemplo simples um sistema de gestão de RH, conhecido como OpenRh.

Se tiver:
*OpenRh.1.0.0.1A * - Significa que o software ainda é Alfa. (testes internos com os testadores da empresa)
*OpenRh.1.0.0.1B* - Significa que o software ainda é Beta. (testes externos com os usuários finais)
*OpenRh.1.0.0.1RC* - Significa que o software é o Release Candidate. (Provável versão final, uma após a B)
*OpenRh.1.0.0.1* - Significa que o software é o final. (Também conhecido como de produção ou ainda stable)
ps: as vezes utiliza-se algumas nomenclaturas como .final ou .stable para definir que o software já está pronto para o mercado.

Para entusiastas ainda há a possibilidade de adquirir software enquanto estão em ambiente de desenvolvimento.
*OpenRh 2.0.0M1* - Significa que o software que teve alguma mudança significativa e assim foi feito um Marco esse marco normalmente é numerado logo pode se ter M1 M2 M3... (Milestone)
*OpenRh 2.0.0R301* - Significa que o software está na revisão 301 no repositório de códigos, aqui a cada commit o usuário (mais fanático) pode testar software feito no dia.
Obviamente esses nomes podem sofrer algumas alterações mas o sentido continua o mesmo.
Ps: Também há o .src que é exatamente o código fonte do projeto em questão.

Conclusão

A principio parece mais burocracia ao desenvolvimento de sistema, todavia as grandes empresas tem notado em experiências sólidas que o uso de diversos ambientes reduzem e muito a quantidade de erros que os sistemas poderiam ter ao serem lançados.
Questões gerenciais ficam bem facilitas com o uso de diversos ambientes. O uso de um repositório de código hoje é essencial, necessário. Seguir boas práticas que grandes empresas seguem pode tornar seus problemas mais gerenciáveis, estar preparado para mudança é o rumo da T.I.

Texto: Autor desconhecido.

Bom link para ler...

2008-02-13T07:12:00.000-08:00

Muito tempo sem postar nada. Venho com apenas um link parar o novo Livro de Martin Fowler - DSL (WIP).

REST - Breves esclarecimentos sobre o estilo arquitetural

2008-01-14T06:11:00.000-08:00

Primeiro esclarecimento:
REST é um estilo arquitetural (simples assim), que pode ser aproveitado para o desenvolvimento de aplicações que utilizem uma rede de comunicação, o termo foi "inventado" por Roy Fielding na dissertação de Ph.D dele.

Segundo esclarecimento:
REST não é um padrão, especificação, ou seja, você não irá ver a Sun, Microsoft ou IBM vendendo um Toolkit para REST. Simplesmente REST é um estilo arquitetural, você pode compreender-lo e desenvolver seus serviços para web (aplicações, web services ...) nesse estilo.

Um exemplo do uso deste estilo arquitetural (REST)

A Web...
Você deseja um serviço, por exemplo um dicionário online.
Você procura esse dicionário (normalmente usando outro serviço de busca da Web).
Como resposta você obtém uma URL que identifica unicamente aquele recurso (serviço). [ www.dicionariorest.com.br].
Pronto agora você consegue tal serviço.

Um ótimo jeito é dar outro exemplo

Uma empresa Xyz deseja oferecer serviços na web que habilitam seus clientes a:

1 - Obter uma lista de produtos.
2 - Obter informação detalhada sobre um produto.
3 - Comprar usando a Internet.

Como seria o jeito REST de se resolver isto.

O serviço está disponível pela URL (única), no exemplo o cliente do serviço deve usar a URL para ter acesso ao serviço.
www.lojadementira.com.br/produtos
O retorno óbvio é uma lista de produtos (HTML) todavia poderia ser especificado qual o tipo de recurso queriamos, por exemplo.
www.lojadementira.com.br/produtos&tipo=xml
Supondo que o serviço retornasse o seguinte xml:

[?xml version="1.0"?]
[lista]
[produto id=www.lojadementira.com.br/produtos/001][/produto]
[produto id=www.lojadementira.com.br/produtos/002][/produto]
[produto id=www.lojadementira.com.br/produtos/003][/produto]
[produto id=www.lojadementira.com.br/produtos/004][/produto]
[produto id=www.lojadementira.com.br/produtos/005][/produto]
[produto id=www.lojadementira.com.br/produtos/006][/produto]
[/lista]

Não reparem na sintaxe (provavelmente) errada do xml acima. Notem a característica chave do REST: A lista própria já traz como acessar o serviço de detalhes do produto. O cliente se transfere de um estado para o próximo examinando e escolhendo entre as alternativas.

Ótimo agora com a lista, o cliente escolhe o produto [www.lojadementira.com.br/produtos/005] e como retorno obtém um novo xml.

[?xml version="1.0"?]
[produto id=1]
[name] tutorial sobre REST [/name]
[price]18.8[/price]
...
[/produto]

(ps: claro que www.lojadementira.com.br/produtos/005 não é se trata do endereço físico da página html www.lojadementira.com.br/produtos/005.html, é somente um modo de acessar unicamente aquele recurso, todavia essa descrição detalhada do produto pode (e deveria) ser dinâmica.)

Algumas características do REST (baseada em redes)

* Geralmente usam-se interfaces unificadas.
GET, POST, PUT e DELETE par prover serviços.
* Stateless: Toda requisição precisa conter toda informação necessária para atender a requisição.
* Tudo é um recurso e tudo é adiquirido/executado pela URL.

Principios do REST

* Dê a tudo (os recursos) um ID (URI)
* Link tudo
Por exemplo um pedido:
[order self='http://example.com/customers/1234' ]
[amount]23[/amount]
[product ref='http://example.com/products/4554' /]
[customer ref='http://example.com/customers/1234' /]
[/order]

Nesse pedido posso facilmente encontrar os recursos relacionados a ele, como cliente e produto.

* Use métodos padrões

Se tudo é um recurso com identidade...

class Resource {
Resource(URI u);
Response get();
Response post(Request r);
Response put(Request r);
Response delete();
}

Exemplo número 9.001

Supondo as seguintes classes de serviço:

public class ServicoGerenciamentoDeProduto{
+getDetalhesDoProtudo()
+atualizarProduto()
+inserirProduto()
...
}

public class ServicoGerenciamentoDeCliente{
+getTelefoneComercial()
+atualizarCliente()
+inserirCliente()
...
}

Num modo REST de resolução poderia ser criado algo semelhando a isso.

interface Resource{
+GET
+PUT
+POST
+DELETE
}

E fazer as classes de serviço implementarem essa interface (um dos princípios sobre a padronização). Essa implementação é por recurso, normalmente um serviço expõem mais de um recurso.

Desculpem pela quantidade de exemplos mas o assunto é muito "abstrato" ou no mínimo díficil de se explicar, acredito que com exemplos ficará mais claro.

Conclusão.

Francamente gostaria de ter deixado mais claro o que é REST e como aplicar, mas estou achando que não consegui, assuntos sobre estilos arquiteturais são complexos de ser entendidos e explicados. Talvez uma leitura nos links abaixo facilite o entendimento. Enfim usar REST é apenas utilizar melhor o jeito HTTP de ser.

Fontes e bons links:
http://www.xfront.com/
http://www.fragmental.com.br/
http://rest.blueoxen.net/cgi-bin/wiki.pl?BenjaminsRESTTutorial
http://forum.rubyonbr.org/forums/1/topics/2212#posts-12150
http://java.sun.com/developer/technicalArticles/WebServices/restful/
A Brief Introduction to REST by Stefan Tilkov

Ps: não se trata de um tutorial ou faq sobre o assunto. Possivelmente há erros no texto, qualquer correção ou adição de informação será bem-vinda.

Um (mal) programador Java aprendendo Ruby - Parte 1

2008-01-11T09:16:00.000-08:00

Algumas características interessantes do Ruby fazem algumas tarefas mais rápidas. Em um programa oo para saber se um objeto é uma instância de uma determinada classe.

Em Java:
objeto instanceof Classe

Em Ruby:
objeto.is_a? Classe

Quando desejo usar herança:

Em Java:
public class Filho extends Pai

Em Ruby:
class Filho < Pai

Quando desejo criar um método que retorne a soma entre dois números:

Em Java:
public int soma(int v1, int v2){
return v1 + v2
}

Em Ruby:
def soma(v1,v2)
v1+v2
end

"Lançando exceções".

Em Java:
if (saldo < saque) throw new Exception("Sem fundos!")

Em Ruby:
raise Exception.new("Sem fundos!") unless saldo > saque

Algo que percebo é que as vezes para implementar características em Ruby, gasto menos linhas de código para o mesmo propósito quando usava Java (bem como o código se transforma em algo mais expressivo também). A principio esta característica de escrever menos assusta e logo vêm milhares de perguntas a cabeça como: quando e como retorno o valor... essa tipagem dinâmica, sei não viu... . Bem sobre algumas características (como o retorno do método) o Ruby utiliza algumas convenções:

Ao invés de digitar ; (em Java, C, C++, C#) para quebra de linha apenas usa o Enter para tal.

Ao invés de usar a palavra-chave return [mesmo que você possa utilizar-la] o Ruby entende que seu último comando será o retorno do método, todavia se quiser usar o return poderá também.

Quanto a tipagem dinâmica não sei muito sobre... quando souber posto aqui.

ps: Este post não é de forma alguma um "flamewar" para provar que uma linguagem é melhor do que outra...

Ruby: usando classe aberta (open classe)

2008-01-09T09:04:00.000-08:00

Extender (não no sentido "carregado" da herança) uma classe já existente.... Interessante recurso, lembro de algo similar no mundo .net os extension methods.

#uma classe já existente.
class Integer

#adicionando métodos a mesma.
def am(*args)
self == 12 ? 0 : self
end

def pm(*args)
self == 12 ? 12 : self +12
end
end

#veja que interessante o uso.
i = 4.pm
puts "4Pm = " << i.to_s #deve aparecer 4Pm = 16
i = 4.am
puts "4Am = " << i.to_s #deve aparecer 4Am = 4

#outro exemplo...
class String
def em_maisculo
self.upcase
end
end

puts "galaxy".em_maisculo

Esse recurso pode facilitar a escrita de interfaces fluente... imagine.

compromisso.adicionar("ler algo sobre ddd").comecando_as(2.Pm).ate_as(4.Pm).hoje()

* Exemplos inspirados numa apresentação de um trabalhador da throughworks.

"Interface fluente" no JavaScript

2008-01-09T05:31:00.000-08:00

Isso mesmo "já embutida":
Ao invés de fazer isso.

elemento = document.getElementById("attachments-box");
elemento.removeAttribute("width");

elemento1 = document.getElementById("format_auto");
elemento1.setAttribute("checked", "true");

Você pode fazer diretamente:
document.getElementById("attachments-box").removeAttribute("width");
document.getElementById("format_auto").setAttribute("checked", "true");

E só pra não perder o costume mais um link de um belo exemplo de uma interface fluente: http://gc.blog.br/2007/09/25/refatorando-para-fluent-interface/

Expressividade na linguagem

2008-01-04T08:55:00.000-08:00

Atualmente existem muitas linguagens de programação no mercado, algumas que fazem parte do "legado" {cobol,natura...} e outras estão em "voga" {java,ruby,c#...}. Fala-se muito em expressividade na escrita de código. A linguagem pode ajudar e muito a criação de código mais expressivo. Como exemplo inicial, duas linguagens, Java já conhecida e admirada e Ruby nova e promissora.
Para se obter o ultimo elemento de uma lista...

Em Java.
aList.get(aList.size -1)
Em Ruby.
anArray.last

É notório que o código parece ser melhor expresso com Ruby.
Agora considere os códigos abaixo:

//C# 2.0
date d = Helper.At(Helper.FromToday(Helper.Days(2)), Helper.Pm(4));
//C# 3.0
date d = 2.Days().FromToday().At(4.Pm);
Veja o quanto a versão 3.0 do sharp é mais fácil de ser "lida".

Outro exemplo:

Em Java:
public List pessoasFisicas(List pessoas) {
List resultado = new ArrayList();
for (Pessoa pessoa : pessoas)
if (pessoa.isFisica()) result.Add(pessoa);
return result;
}

Em Ruby:
def pessoasFisicas(pessoas)
return pessoas.select {|e| e.isFisica}
end

Sem comentário para essa última demonstração.
"Ser expressivo" pode facilitar futuras manutenções, extensões e integrações no código.

Os exemplos foram roubados discaradamente de
* HumaneInterface - Martin Fowler
* Artigo no InfoQ

ps: os códigos podem estar errados.

Ótimo post sobre Interface Fluente.

2008-01-03T10:42:00.000-08:00

No site abaixo verá um exemplo bastante interessante, principalmente para quem trata requisições (no modelo "JSP/Servelt") em páginas.
http://fragmental.tw/2007/10/18/notes-on-language-adaption/
Enjoy it.

Fluent Interface ...

2007-11-30T19:42:00.000-08:00

Primeiro a definição depois os exemplos.

*DSL ==> *é uma linguagem (mini liguagem) projetada para um tipo especifico de tarefa, isto é justamente o contrário de linguagens para proposito geral como Java, C ou C#.
*Fluent Interface (Interface Fluente)* ==> objeto que é capaz de deixar as suas responsabilidades mais expressivas a linguagem. (:S confuso, mas o exemplo ajudará)

Para se aprender algo nada melhor do que exemplos./ (aprender com exemplos não dá sono de acordo com Fowler, eu acho que ele está certo)/
Irei apresentar aqui dois exemplos: um simples e outro mais interessante.

*Exemplo Simples*

Supondo que tenho um objeto que representa o conceito Carro.

public class Carro{
private String nome;
private String marca;
private int portas;
public Carro(){
}
// métodos de acesso as propriedades encapsulados...
}

Quando fossemos "usar" esse objeto fariamos...

//***
Carro fusca = new Carro();
fusca.setNome("fusca");
fusca.setMarca("VW");
fusca.setPortas(2);
//***

Tentando aplicar o conceito de Interface Fluente, definiriamos uma Interface

public interface ICarro{
ICarro setNome(String nome);
ICarro setMarca(String nome);
ICarro setPortas(int nome);
}

//classe que implementa essa interface.
public class Carro implements /ICarro/{
private String nome;
private String marca;
private int portas;
public Carro(){
}

public ICarro setNome(String nome){
this.nome = nome;
return this;
}
public ICarro setMarca(String nome){
this.nome = nome;
return this;
}
public ICarro setPortas(int numero){
this.portas = numero;
return this;
}

}

*Agora nosso mesmo exemplo.( O simples ainda )*

//** ANTIGO
Carro fusca = new Carro();
fusca.setNome("fusca");
fusca.setMarca("VW");
fusca.setPortas(2);
//**

//** COM O CONCEITO DE INTERFACE FLUENTE
Carro fusca = new Carro();
fusca.setNome("fusca")
.setMarca("VW")
.setPortas(2);
//Note como cada método de set retorna o objeto aplicando outro método,
dando mais expressividade
//a linguagem.
//**

Isso parece meio bobo, mas para um *exemplo inicial* é até "bonzinho".

*Exemplo Interessante

*Outro possível exemplo, um criador de sql. Em tempos que o padrã JPA está se consolidando, se trata de exemplo não muito usual (sem bem que se pode usar-lo para criar as JPQL)... mas ao exemplo.
Se quiser "conversar" com o SGBD expresse em SQL. Uma consulta SQL é
similar ao exemplo abaixo:*

SELECT* campo1,campo2, campo4 (ou * para todos)
*FROM* tabela1
*[INNER | OUTER ...] JOIN* tabela2 *ON*
*WHERE* condicao1
*AND *condicao2
*OR* condicao2
*ORDER BY* campo1, campo2 ....

O exemplo acima não mostra todas as potencialidades da linguagem SQL mas serve para o propósito do exemplo.

1º A criação da Interface

public interface IConsultaSql{
IConsultaSql select(String campos);
IConsultaSql from(String tabela);
IConsultaSql innerJoin(String tablea);
IConsultaSql outterJoin(String tablea);
IConsultaSql on(String condicao);
IConsultaSql where(String condicao);
IConsultaSql and(String condicao);
IConsultaSql or(String condicao);
IConsultaSql orderBy(String campos);
}

Logo após a criação da classe que implementa a interface.

public class ConsultaSql implements /IConsultaSql/{
private StringBuilder construtor = new StringBuilder();
//note que o próprio StringBuilder aplica conceitos de interface fluente.
public ConsultaSql(){
}

public IConsultaSql select(String campos){
construtor.append("SELECT ")
.append(campos);
return this;
}

public IConsultaSql from(String tabela){
construtor.append(" FROM ")
.append(tabela);
return this;
}

public IConsultaSql innerJoin(String tabela){
construtor.append(" INNER JOIN ")
.append(tabela);
return this;
}
public IConsultaSql outterJoin(String tabela){
construtor.append(" OUTTER JOIN ")
.append(tabela);
return this;
}
public IConsultaSql on(String condicao){
construtor.append(" ON ")
.append(condicao);
return this;
}
public IConsultaSql where(String condicao){
construtor.append(" WHERE ")
.append(condicao);
return this;
}
public IConsultaSql and(String condicao){
construtor.append(" AND ")
.append(condicao);
return this;
}

public IConsultaSql or(String condicao){
construtor.append(" AND ")
.append(condicao);
return this;
}
public IConsultaSql orderBy(String campos){
construtor.append(" ORDER BY ")
.append(condicao);
return this;
}

public String getSql(){
String retorno = construtor.toString();
return retorno;
}
}

*Veja o uso.*

ConsultaSql con = new ConsultaSql();
con.select("nome,telefone")
.from("pessoa_fissica pf").innerJoin("contatos ct").on("pf.id=ct.pf_id")
.where("pf.nome like %?%")
.and("pf.idade>18").orderBy("nome,idade");

*Bem mais expressivo... mais flexível*

Senão engano o Hibernate está implementando [ou tem implementado] algo assim para criar os
objetos Criteria.

public String getSql() throws SqlIncorretoException{
String retorno = construtor.toString();
Sql.valida(retorno);
return retorno;
}

Uma nova característica do java 5, o varargs também pode ajudar a aplicar "esses novos conceitos" de interface fluente.

*TRADICIONALMENTE*
Produto bola;
Produto cafe;
Produto monitor;
Compra compra = new Compra(cliente);
compra.adicionarItem(bola);
compra.adicionarItem(cafe);
compra.adicionarItem(monitor);

*COM USO DE VARARGS
*
Produto bola;
Produto cafe;
Produto monitor;
Compra compra = new Compra(cliente);
compra.adicionarItem(bola,cafe,monitor);

Enfim são todos conceitos muito abstratos e ainda em discussão, logo "nada" é certo sobre esse tema. No mínimo o assunto é interessante e intrigante para os desenvolvedores e clientes (quem realmente interessa). Se acostume com esse novo paradigma /expressividade no desenvolvimento. (tudo mais perto da linguagem de
domínio do sistema)

/ps: perdoem os erros de português.
/Links interessantes sobre os assuntos/.

* _http://www.fragmental.tw_ (Blog sobre pesquisa em DSL)
* _http://martinfowler.com/bliki

/FluentInterface.html_ (Fowler
"ditando" sobre o que é uma Interface Fluente)
* _http://www.infoq.com/presentations/domain-specific-languages_
(Vídeo com uma introdução sobre DSL)