Como Instalar Google GO no Ubuntu e Mac Os

Vou descrever quais são as etapas necessarias para instalação do Google GO, a nova linguagem de programação do Google, no Ubuntu 9.10 e no Mac OS 10.5 (Leopard).

Pré-requisitos para instalar e usar o GO:

• Mercurial: ferramenta para controle de fontes (repositório) distribuído.

• GCC: compilador C.
  

O Python é pré-requisito para o Mercurial.

Uma vez que essas ferramentas tenham sido instaladas, a proxima etapa seria configurar algumas variáveis de ambiente que o GO usa:

• GOROOT: diretório raiz da instalação do GO.

• GOBIN: diretório com conteúdo binário.

• GOOS: sistema operacional.

• GOARCH: indica qual arquitetura para compilação.
  

A próxima etapa seria baixar e compilar os fontes do GO, depois é começar a programar.

No Ubuntu 

Os comandos para instalação do Mercurial e GCC são:

$ sudo apt-get install mercurial
$ sudo apt-get install bison gcc libc6-dev ed make

Na sequencia é preciso criar a estrutura de diretórios e configurar as variáveis de ambiente (no arquivo ~/.bashrc):

$ mkdir $HOME/go
$ mkdir $HOME/go/bin
$ mkdir $HOME/go/src

export GOROOT=$HOME/go/src
export GOBIN=$HOME/go/bin
export GOOS=linux
export GOARCH=386
export PATH=$PATH:$HOME/go/bin

Para baixar os fontes do GO, use o seguinte comando:

$ hg clone -r release https://go.googlecode.com/hg/ $GOROOT

Para compilar os fontes do GO (a partir do dirétorio src):

$ cd $GOROOT/src
$ ./all.bash 

Ambiente configurado no Ubuntu!

No Mac OS

Baixe o Mercurial aqui, e instale o dmg.
Caso ainda não tenha o xCode, baixe aqui para resolver o GCC.

A seguir a criação das pastas e configuração das variáveis de ambiente no arquivo .bash_profile:

$ mkdir $HOME/go
$ mkdir $HOME/go/bin
$ mkdir $HOME/go/src

export GOROOT=$HOME/go/src
export GOBIN=$HOME/go/bin
export GOOS=darwin
export GOARCH=386
export PATH=$PATH:$HOME/go/bin

Para baixar os fontes do GO, use o seguinte comando:

$ hg clone -r release https://go.googlecode.com/hg/ $GOROOT

Para compilar os fontes do GO (a partir do dirétorio src):

$ cd $GOROOT/src
$ ./all.bash

Pronto! Agora é só partir pro Hello World, veja um exemplo.

The Developers Conference 2009 simplesmente incrivel!

Nos dias 06 e 07 de Novembro em São Paulo aconteceu The Developers Conference 2009, terceira edição do maior e melhor evento Java do Brasil promovido e organizado pela Globalcode. As 2 edições anteriores foram excelentes, mas esse ano o evento foi fantástico, com uma grade e palestrantes de altíssimo nível, como por exemplo Rod Johnson o pai/guru do Spring.

O TDC 09 foi realizado também na Guanabara prestigiando o galera do Rio de Janeiro (UFF), depois de passar por Florianópolis (V.Office).

Outra novidade foram os Lightning Talks, apresentações rápidas (+ ou - 15 minutos) com demonstrações práticas que aconteceram no decorrer das palestras. Tive a oportunidade de apresentar sobre GWT e Guice, bem introdutório mas focando no quanto o Google aposta na comunidade Java.

Falando um pouco mais sobre os palestrantes, além de Rod Johnson também tivemos a oportunidade de ver Mike Keith (Oracle) co-líder da especificação de JPA, Ed Burns (Sun) líder da especificação de JSF 2, Alejandro Guizer engenheiro de Software da Red Hat e Francisco da Google substituindo Chris Schalk, e outras personalidades da comunidade nacional. Foi uma oportunidade ímpar para fazer networking.

As palestras superaram as expectativas! No primeiro dia, Rod Johnson em seu Keynote comentou sobre o Futuro do Java EE como plataforma e as linguagens mais alto nível operando por cima, outra tendência é o Java como plataforma no universo Cloud Computing. Na sequência Ed Burns, Mike e Rod comentaram um pouco sobre o início de suas vidas profissionais, depois passaram valiosas dicas para quem esta começando a traçar carreira.

Na volta do almoço Mike Keith apresentou detalhes sobre o Java EE 6, a plataforma cada vez mais robusta, madura e simples para o desenvolvimento dia-a-dia. Ed Burns apresentou a padronização da nova forma de criar telas com JSF2 abusando de reutilização e composição, Composite Components. Na sequência Yara e Spock apresentaram o projeto demonstração do NetBeans e GlassFish mantido pela Globalcode, o Scrum Toys, uma case mostrando a força da comunidade brasileira!

Já no sábado fiquei muito empolgado com a palestra do Rod sobre o Spring 3.0, a evolução da consagrada suite de tecnologias para desenvolvimento, o que mais me chamou a atenção foi Spring Roo como uma alternativa para Rails. Depois do almoço Mike apresentou detalhes da especificação JPA 2.0, mostrou os novos recursos dessa JSR.

Francisco (Google) e Rafael apresentaram sobre a plataforma Cloud do Google o App Engine. Francisco comentando sobre a nova possibilidade de desenvolvimento de software com Cloud e um pouco da estratégia do Google nesse segmento. Rafael apresentou exemplo de como rodar JSF2 no Cloud, algo novo até então, outro ponto positivo pra comunidade brasileira!

Fechando o evento tivemos o Debate Cloud Computing na visão dos Players: Google (Francisco) + Oracle (Mike) + Sun (Ed) + Spring Source (Rod) + Yahoo (Bene) + JBoss Red Hat (Alejandro) mediado pelo Júlio (Globalcode). Esse bate-papo bem descontraído teve como objetivo mostrar do ponto de vista de cada um qual é a expectativa sobre o Cloud Computing, o que isso pode trazer como solução e/ou serviços para nós desenvolvedores.

Gostei muitos dos Lightning Talks, principalmente "Boas práticas com Spring" apresentado pelo Jun, "WebBeans/Context Dependency Injection na prática com Weld" - novo Seam - da JBoss e "Melhorando performance de JPA com Spring Web Flow" do Spock com dicas preciosas para o desenvolvimento com JSF.

Durante o evento o Vinicius Senger despertou o lado Prof. Pardal da galera, apresentando vários Robôs usando o Arduíno, mostrando um pouco do que a Globalcode pretende realizar: como pode ser simples e divertido usar robótica, fique por dentro no blog Elétron Livre!

O evento foi incrível, além de muito conteúdo, networking e diversão tive a oportunidade de rever velhos amigos e conhecer pessoalmente grandes figuras como o Bene (Benedicto Franco) da Yahoo. Conheci o pessoal do Rio (Universidade Federal Fluminense) e uma galera de Uberlândia. No ano que vem vou estar presente nas versões do TDC!

• Vejas Fotos do Evento aqui
• Site do Evento
  

Client Subversion com Python

Existem vários clients e plugins disponíveis para acessar e manipular o respositório do subversion. Uma categoria de clients chamada Subversion Language Bindings permite o acesso ao svn via API, com suporte a linguagens como Java, Python, C++, veja mais detalhes aqui.

Abaixo um exemplo de código em Python usando o extensão pysvn que faz uso desse mecanismo e monta um relatório da quantidade de recursos manipulados agrupados por Desenvolvedor/Autor e por Data.

import sys, pysvn, re
from datetime import date
import datetime

def repos(work_path):
    "Get the svn repository url"
    info = pysvn.Client().info(work_path)

    if info.repos:
        return info.repos

    # special case - checked out the trunk
    if info.url.endswith("/trunk"):
        return re.sub(r"/trunk$", "", info.url)

    # default to the current dir's url
    return info.url

def arg(index):
    # find argument, if doesnt exists return None
    args = sys.argv[1:]
    try:
        return args[index]
    except IndexError:
        return None

def dayBeforeToday(d):
    try:
        diff = datetime.timedelta(days=int(d))
        return date.today() - diff
    except:
        return None

def query(repos, author, days):
    print "get in: "+repos

    logs = []
    for l in pysvn.Client().log(repos, discover_changed_paths=True):
        logs.append({"author": l["author"], "date": date.fromtimestamp(l["date"]), "changed_count": len(l["changed_paths"])})

    if not (author in [None, "-", "." ]):
        logs = list(filter_logs(logs, lambda k, v: k == "author" and v == author))

    dt = dayBeforeToday(days)
    if not (dt in [None, "-", ".",  "0"]):
        logs = list(filter_logs(logs, lambda k, v: k == "date" and v >= dt))

    return logs

def filter_logs(logs, where=lambda k, v: True):
    #apply filter in log results
    for l in logs:
        for k, v in l.items():
            if where(k, v):
                yield l

def format2cols(items):
    if len(items) == 0:
        return "\n"
    max_width = max(len(str(x)) for (x,y) in items)
    template = "%%%ds %%s" % max_width
    return "\n".join(template % (x, y) for (x, y) in items)

def sort_uniq_c(seq):
    "Duplicate unix's 'sort | uniq -c | sort -nr'"
    count_first = ((y,x) for (x,y) in histogram(seq, ["author", "date"]).items())
    return format2cols(sorted(count_first, reverse=True))

def histogram(logs, groupBy):
    result = {}
    for l in logs:
        k = ""
        for s in groupBy:
            k += str(l[s])+" "
        result.setdefault(k,0)
        result[k] += l["changed_count"]

    return result

if __name__ == "__main__":
    _author = arg(1)
    _days = arg(2)
    print sort_uniq_c(query(repos(work_path = "."), _author, _days))

Na realidade usei esse script python como base, nesse script além dos filtros por Autor e/ou Dias a contagem é realizada por resources no(s) commit, a saída é agrupada por autor e data de commit.

JSF e Portlets no JBoss Portal

Dias atrás estive envolvido em um "projeto case", com o propósito de experimentar a arquitetura de Portais e Portlets. O software portal escolhido foi o JBoss Portal versão 2.7, que além do Portlet Container possui elementos bem interessantes, como o modulo de CMS e Portlet Bridge.

É possível instalar o JBoss Portal em JBoss AS existente. Fiz isso na versão 4.2, a única configuração necessária no meu caso foi o datasource do portal, mas isso pode ser mais complexo dependendo de como esta configuração de bibliotecas do servidor! A documentação é boa, existem vários exemplos de portlet e o próprio fonte do portal - implementado sob JSF e Hibernate - de fácil customização.

Um recurso que me chamou a atenção foi o JBoss Portlet Bridge, que permitir criar portlets utilizando JavaServer Faces (v 1.2) + Seam + RichFaces, com suporte Facelets. Com isso é possível criar um aplicação composta por portlets com todos os benefícios do JSF, sem se preocupar com a API e curva de aprendizado de Portlet, PortletContainer e Portais.

Montei um aplicativo relativamente simples, utilizando Facelets + RichFaces c/ JBoss Bridge, gerenciado pelo JBoss Portal dentro do JBoss AS 4.2. Nessa estrutura a programação é a mesma de um aplicativo MVC comum, ou seja, criação de telas com Facelets usando as tags JSF e RichFaces, o Managed Bean resolvendo a integração do View com Model. Na camada model utilizei Pojos com Hibernate. O único portlet utilizado na aplicação foi o javax.portlet.faces.GenericFacesPortlet, e no JSF o ViewHandler org.jboss.portletbridge.application.PortletViewHandler.

Encontrei pequenos problemas nessa integração, principalmente com alguns componentes do RichFaces, mas todos foram revertidos. Acredito que mistura tenha funcionado justamente por todos os componentes serem JBoss.

Java EE define 2 especificações para portlet: JSR 168, JSR 286. O JBoss Portlet Bridge é um draft para outras 2 especificações a JSR 301 e a JSR 329 que visam padronizar a integração entre Portlet e JSF.

Seam Component x Contextos

Complementando o ótimo post do Dr. Spock, na sequência coloco os tipos de Seam Component e quais contextos do Seam podem ou devem ser usados:

• Session Stateful (EJB) - por default é mantido em APPLICATION. Nunca devem ser associados a STATELESS ou PAGE.

• Session Stateless (EJB) - sempre mantido em STATELESS. Toda cada vez que requisitado o Seam busca uma instância (lookup).

• JPA Entity class - por default é mantido em CONVERSATION, nunca devem ser usados em STATELESS já que em algum momento devem ser sincronizados na base de dados.

• JavaBean / POJO - por default ficam em EVENT.

• Message Driven Bean - atua como uma listerner para Topic ou Queue, não é mantido em contexto Seam.
  

Testando Google Wave

Essa semana fui um dos vários convidados para testar o Google Wave. A ferramenta esta em fase de testes, vários ajustes e melhorias devem ser efetuados, na minha opnião o conceito da ferramenta eh show de bola. Principalmente a ideia de plataforma aonde vc consegue criar/estender elementos e rodar no wave.

Veja essa página que comenta sobre extensões do Wave:

Vc tem 2 alternativas para criar elementos para o Wave:

• Robots - robô que atua como um participante/convidado de uma determinada Wave, como por exemplo um corretor ortográfico.
• Gadgets - pequenos aplicativos que rodam dentro da Wave, e compartilham seu estado para todos os participantes da mesma Wave, como por exemplo um mapa com a rota para uma balada.

JBoss Seam Timeout Conversation

Essa semana estava fussando bastante no Seam, e de repente pintou uma questão:
Qual é o timeout default do conversation caso o usuário não aciona uma requisição para o método @End? Será a mesma da Session?

A resposta é 10 minutos por default, encontrei isso no livro Seam In Action (pag. 300), ótimo por sinal!

Vc pode sobreescrever no component.xml, usando a tag:
core:manager timeout="600000"

Uma outra opção é usar a property timeout da tag page no mapeamento de view's (pages.xml):
page id="/cadastro.xhtml" timeout="300000"

Hibernate Performance

Ótima apresentação do Emmanuel Bernard - co-autor de Hibernate Search in Action - mostrando algumas práticas e observações para escalar c/ Hibernate.

Concorrência - Iterar HashSet

Na sequência um exemplo de código que encapsula acesso a um HashSet de forma segura (nem tanto...):

public class IteracaoVulneravel {

  private Set palavras = new HashSet();

  public synchronized void removePalavra(String palavra) {
    palavras.remove(palavra);
  }

  public synchronized void addPalavra(String palavra) {
    palavras.add(palavra);
  }

  //pode lançar java.util.ConcurrentModificationException
  public void print() {
    System.out.println("Palavras = "+palavras);
  }
}

O detalhe fica no método print, o compilador implicitamente cria código para navegar na coleção usando o Iterator, para realizar o print dos elementos.
Durante a iteração no elementos ninguém garante que uma outra thread acione o método addPalavra. Caso isso aconteça uma java.util.ConcurrentModificationException será lançada!

Para evitar isso o recomendado seria sincronizar a coleção, veja.

Interessante observação do livro Java Concurrency in Practice.

Extensões GWT

Essa semana estava finalizando a estrutura para o mini-curso de Gwt, já esta quase fechado!
Um outro detalhe interessante a respeito dessa tecnologia eh a possibilidade de criar ou usar bibliotecas/extensões de Componentes Visuais (UI), tornando o desenvolvimento bem mais produtivo.

Desenvolvendo com gwt tive experiência com a extensão GXT, Gwt Ext através do gwt usa o framework javascript Ext, que sem duvida é uma suite bem completa e "rica". Veja o show case aqui.

Essa semana encontrei uma outra alternativa um concorrente chamado SmartGwt. Os componentes são bem parecidos com o GXT, mas na minha opinião a grande vantagem é a licença, além de open-source o SmartGwt eh LGPL. Compare, acesse o show case aqui.

Gosto muito do conceito de bibliotecas visuais, provavelmente por usar essa ideia quando trabalhava com Delphi. Um outro exemplo que dispensa comentarios é o JSF que no seu core foi projeto para isso, confira aqui.

GWT no OpenTDC

OpenTDC foi demais, só pra variar a Globalcode detonando em mais um evento. Curti a palestra de Arquiteturas JSF, principalmente pela abordagem na visão de sistemas corporativos, maiores. As palestras sobre Agile e TV Digital foram show de bola!

No fim do eventou rolou um painel de JavaFX(Maurício Leal), Flex(Rafael Nunes) e GWT(Eu). Foi interessante falar do GWT apesar do tempo ter ficado apertado.

Parabéns pra Globalcode!

RIA pra cá, RIA pra lá...

Faz um certo tempo que venho me dedicando bastante em soluções RIA, principalmente em pesquisa e experimento das principais alternativas. Trabalhei em projetos c/ JSF (RichFaces - Facelets), Flex, e nos últimos dias com GWT, sem contar nas pesquisas e testes com JavaFx (nada em produção).

Na minha opinião classifico o Flex e JavaFx trazem um conceito de RIA muito mais "rich" do que boa parte das aplicações corporativas de hoje. Essas tecnologias tem um poder de iteratividade incrível, me questiono em relação a sistemas comuns, CRUD, "precisam dessa riqueza"? Acho que o JavaFX venha pra substituir a proposta Swing + Java WebStart, abraçando o mobile.

Nenhuma dessas tecnologias resolve tudo (silver bullet), mas é interessante ter experiência aonde nossa tecnologia preferida, no meu caso especificamente o JSF, pode não ser a melhor solução para tal cenário. No ultimo projeto que atuei o escolhido foi o GWT, a equipe já tinha uma experiência com Swing, só pra variar o tempo era curto o risco grande e não tinha como cobrir o risco em adotar JSF sem nenhum contado anterior.

Essa experiência foi interessante, além de aumentar o conhecimento, o melhor foi enxergar do outro lado do muro. Adquirir mais argumentos para comparações e levantar pontos fracos e fortes de ambos os lados. Um ponto interessante, precisa de um outro post, é qtde de legados e diversas opções que vão ficar por ai... Já pensou daqui uns 10 anos?

De Java para Python

Algumas dicas que podem ajudar.

Open TDC 2009

Inscrições Abertas para o OpenTDC 2009 - Um Evento Java Gratuito realizado pela Globalcode com o objetivo de difundir o conhecimento e fortalecer ainda mais a comunidade de profissionais que trabalham com Java.

O evento vai abordar algumas tendências em desenvolvimento como TV Digital, JavaFX e Flex, Arquiteturas Java EE com JSF, JBoss Seam e Spring e, também, uma palestra muito interessante sobre o uso de Java e Robótica aplicados à automação residencial e ao ensino de programação.

Não perca tempo, inscreva-se e participe !

Data: 17/05/2009 (Domingo)

Local: Universidade Anhembi Morumbi Campus Vila Olímpia. Rua Casa do Ator, 275, Itaim Bibi, São Paulo-SP

Inscrições: http://www.thedevelopersconference.com.br/opentdc/2009/sp

Outras informações: http://www.globalcode.com.br

Não perca!

Web Beans chegando...

Primeiro preview liberado!
Veja.

Salvando entidades além do convencional

Outro dia encontrei algumas referencias comentando/procurando uma solução simples a respeito da persistência de entidades que possuem relacionamentos com certa complexidade (além do CRUD básico) com JPA/Hibernate, algo normal ao usar "domain model".

Pra não voltar aos DTO's, uma abordagem - questionável é claro - seria usar o id do objeto de origem para resgatar uma outra instância sob o escopo do EntityManager/Session e setar os "pedaços"/dados modificados no objeto origem na referencia gerenciada.

...
//recuperando instância gerenciada
Pedido pedidoGerenciado = getPedidoById(pedidoOrigem.getId());

//passando informações desejadas...
pedidoGerenciado.setDataEntrega(pedidoOrigem.getDataEntrega());
...

Ao encerrar a transação ou acionar o flush as alterações serão propagadas ao Banco.

Sunday Reference

Domingão resolvi dar uma revisada na API do Java que trata referencias de objetos (Heap + GC). Semana passada me deparei com algumas delas nos testes que estava fazendo (post anterior).

Na realidade brinquei um pouco as especializações de java.lang.ref.Reference. Representam o modelo de referencia de objetos do Java e influenciando a execução do Garbage Collector (GC). São elas:

• WeakReference: um wrapper de uma referencia (qualquer objeto) "fraca", quando necessario o GC ira eliminar.

• SoftReference: outro wrapper, mas numa situação intermediaria nem tao fraca e nem tao forte. Na pratica tem uma durabilidade maior do que weak, mas qdo necessario - se necessário - o GC vai eliminar. Uma alternativa interessante para cache.

• PhantomReference: o wrapper mais "frágil", o objeto já recebeu sua doze letal sem chance de escapar da pena de morte. Não há recuperação, o método get sempre retorna null.

Além dessas 3, temos outras classes nessa API:

• ReferenceQueue: mantém as referencias elegíveis enfileiradas.

• WeakHashMap: Map composto pela chave WeakReference e valor a referencia, que sabe eliminar a chave qdo o valor for coletada pelo GC. Em outras coleções o WeakReference (ou os outros) não são removidos, apenas a referencia encapsulada.

Acesse o javadoc e confira.

JVM - "Caixa Preta"

Gerenciar e monitorar os componentes e recursos utilizados por uma aplicação é uma tarefa complexa. Descobrir a causa de OutOfMemory não é algo simples, vc pode encontrar varios sites comentando sobre o problema e tentando apresentar uma solucao. O óbvio seria fazer uma analise da sua aplicação, mas como fazer um "top" para o Java?

Pra isso temos o "profile", ferramente que monitora "de cabo a rabo" o que o aplicativo esta fazendo e consumindo. Na teoria a ferramenta é perfeita, mas na pratica o uso pode ser inviável. Alguns colegas até brincam dizendo que "profile é perfeito, desde que vc não use em produção"! Por mais que vc tenha replicas do ambiente de produção, uma ótima cobertura de testes de stress/utilização, infelizmente alguns comportamentos só ocorrem no ambiente real! E agora?

Junto com a evolução da linguagem Java, a JVM também vem evoluindo bastante no quesito rastreabilidade e monitoramento, no Java 6 foram incorporadas algumas ferramentas com essas características. Na semana passada gastei um tempo estudando e testando algumas dessas ferramentas:
- jmap: faz um dump dos objetos da memória em arquivo físico: > jmap -dump:file=heap.bin
- jhat: ferramenta usada para fazer analise do dump: > jhat -J-mx512m heap.bin
- VisualVM: ferramenta gráfica para acompanhar/monitorar sua aplicação durante a execução. Mais funcionalidades do que o JConsole.

A partir da versão 6, é possível usar um parâmetro solicitando um "dump automático" da memória no caso de um OutOfMemory. Adicione o parâmetro -XX:HeapDumpPath=path_to_file no comando java (avalie o custo).

Tomara que com a evolução da plataforma no geral, essas ferramentas continuem melhorando, simplificando a vida de quem desenvolve e cuida do ambiente Java.

Mas, em casos mais complexos talvez vc tenha que apelar para o Profile, pagando o preço. Atualmente estou trabalhando com o Introscope da CA, uma ferramenta bem completa com consumo razoável, funciona sem "derrubar" o servidor.

Tive algumas experiencias com JProfile e YourKit.

JSessionId em múltiplos contextos

Quando 2 aplicações dentro de um mesmo host/domínio usam sessão, se permitido, um cookie que armazena o jsessionid será gerado na maquina do cliente. Apenas um cookie ja que a criação é por dominio e não por contexto. Aparentemente nenhum problema, mas isso pode gerar um comportamento estranho e difícil de identicar.

No server-side (container) para as 2 aplicações teremos 2 instâncias de HttpSession um por contexto, da forma que deve ser. O jboss sabe mapear a request com o HttpSession do contexto correto, sem problemas.

Mas e se ...? O problema:

• A aplicação X, com o erro intermitente, tem um time-out de session de 5 minutos.
• X possui uma tela faz busca em outro contexto, a aplicação Y.
• O host de Y eh o mesmo de X, e o seu time-out é de 2 minutos por exemplo.
• O usuario ao autenticar em X e abrir a tela que aciona Y, sem saber possui 2 sessions, uma para cada aplicação, mas somente um cookie!
• Caso o usuário depois ficasse 2 minutos trocando uma idéia no msn ou tomando um cafézinho, ao voltar pra tela que aciona Y, uma nova session seria gerada, já que a anterior expirou. Nova session, novo jsessionid, novo cookie!
• Ao fazer uma request para X, o container ira receber um jsessionid desconhecido para o contexto, e ai adivinha? Session "perdida".

Ficamos quase uma semana de cabelo em pé, para descobrir o porque do "sumiço" da session Demorou pra se ligar nesse detalhe.

AOP em JavaScript

Usando AOP em JavaScript, aqui.

Spring Rich Client

Essa é a bola da vez...
Aqui a documentação, muito superficial por sinal. Nao imagina que o spring tinha "uma extensão" pra isso. Bem legal a swingueira!

Importar certificado JVM

Pra guardar...
Abaixo comando de import do certificado digital para jvm:

$ keytool -import -trustcacerts -keystore <%JAVA_HOME%>\jre\security\lib\
    cacerts -storepass changeit -noprompt -alias mycert -file mycert.cer

mycert=nome do certificado.

Class x Prototype

Ótima comparação entre conceito de Classes (O.O.) versus Prototipação, mozilla.

MooTools

+ um frame js.

Richfaces + Spring

Artigo de Richfaces (muito bom) com Spring (as coisas mudam).

10 Things Every Software Architect Should Know

see

JEE c/ Produtividade

Já faz um tempo que me dedico (pesquisa + trabalho) na construção aplicações web em Java c/ produtividade e qualidade. Trabalho com JSF desde 2006, no início como qualquer tecnologia foi bem complicado, mas com o passar do tempo a "coisa" evoluiu.

Definindo o túnel tempo, nos primórdios tinhamos o Servlet para gerar o "html dinâmico", depois veio JSP com a flexibilidade de custom tags, que na verdade não pegou. O sucesso do Struts, Webwork, Spring MVC e outros, vem com a demanda de produtividade, qualidade e a experiência do mercado e da comunidade.

Depois de um tempo chegou o JSF, que na minha opnião traz conceitos bem interessantes, não só em padronizar o MVC mas tambem no apelo de componentes U(ser) I(nterface). Conceito adotado antigamente por ferramentas como Delphi (velhos tempos) e VB (.NET), com foco na produtividade. Fico com a impressão que JSF e JSP, numa abordagem inicial mais simples, não "alavanca" a tal produtividade.

Dos últimos 2 projetos que liderei com JSF, o primeiro usando JSP e o segundo c/ Facelets (xhtml), foi realmente notável aumento de produtividade e qualidade no 2 projeto. Alem dos templates, que trazem uma grande agilidade e reuso, o que mais me impressionou foi a simplicidade de criação de componentes, like tag file, que o Facelets prove. Inicialmente vc "perde" um tempo customizando os componentes, mas depois a agilidade acaba valendo muito a pena.

Alguns dos varios componetes que customizamos:

• botões
• colunas
  
• colunas c/ links
• links
  
• datatable
• modal message
  

Com o facelets o JSF realmente mostra seu poder de fogo!
Na Globalcode temos um ótimo mini-curso falando sobre o assunto, "JSF e Facelets um casamento perfeito".