Meta-"Qualquer coisa" é ("Qualquer coisa")2

Ou seja,

Meta-"Qualquer coisa" é "Qualquer coisa sobre "Qualquer coisa""

Assim, podemos ter coisas como Meta-dados (Dados sobre dados), Meta-Teoremas, Meta-Matemática e Meta-Frameworks.

Temos, portanto, uma Framework sobre Framework(s). Mais precisamente, o sentido dado é de uma framework agregadora de outras frameworks, ao invés de um framework que descreve outras frameworks, algo que o prefixo meta poderia sugerir.

Epistemologia à parte, de que raio é que estou aqui a falar?

Estou a falar de agregadores de frameworks, neste caso em java, que conjugam um conjunto de frameworks base, ligando as diversas peças, e facilitando o uso por parte do utilizador. Desta forma os diversos componentes estão agregados de uma forma minimamente provada ou testada e o tempo de configuração do projecto é incrivelmente reduzido. Podem inclusivé servir como objecto de estudo para observar boas práticas.
Embora seja contra tudo o que seja ideia de criar frameworks base internas a empresas e usar sempre produtos open-source, meta-frameworks são uteis e não são mais que uma definição formal da pilha tecnológica do projecto ou, se a empresa trabalhar dessa forma, da pilha tecnológica da empresa.

Arrancar com um projecto deverá ser tão simples como gerar uma estrutura base do projecto, já com todos os componentes wired up e pronta a compilar. Também deve ser possível importar o projecto do IDE de eleição da pessoa. Repito, da pessoa. Ao contrário do que acontece em muitas empresas, na minha opinião o IDE deve ser uma , sendo que a maioria das frameworks disponibilizam pelo menos para Eclipse e Netbeans.

No paradigma web, poderiamos pois ter uma framework que junta uma tecnologia de mapeamento OR, uma de caching, uma de Dependency Injection/Inversion of Control, uma de apresentação, uma de templating e mais quantas sejam necessárias; mas podemos aplicar isto a qualquer paradigma que queiramos.

Destaco as seguintes frameworks (que são as que conheço):

• Keel

O projecto Keel está morto (não há actividade aparente desde 2004). Apenas é interessante por ter sido a primeira framework deste género com que tive contacto.

• Appfuse

O Appfuse é provavelmente o projecto deste género com maior sucesso e maior disseminação. Liderado pelo Matt Raible, reconhecido especialista em tecnologias web, o Appfuse é na realidade uma colectânea de meta-frameworks.
Basea-se no Maven, usando archetypes, para rapidamente criar esqueletos de projectos. Depois é possível gerar o projecto para o IntelliJ IDEA, Eclipse ou Netbeans e usar qualquer uma das bibliotecas disponíveis no Reference Guide – é possível rapidamente montar um sistema com muito pouco trabalho.
O Appfuse, como usa POJOs e Spring, possibilita criar CRUDs rapidamente com uma simples acção Maven.

• IWebMvc

O IWebMvc é a mais recente meta-framework de que tomei conhecimento. É criada por um senhor chamado Jose Noheda, que é o responsável pela integração com Spring no projecto DWR. É com naturalidade então que ele criou uma meta-framework que agrega DWR + Dojo + Spring + Hibernate/JPA.
Ainda está na sua primeira versão, mas dada a qualidade do DWR isto promete. Certamente uma meta-framework a analisar.

• Parancoe

Parancoe é uma meta-framework criada pelo Lucio Benfante, líder do JUG Padova.
A pilha tecnológica de Parancoe é DWR + Spring MVC + Spring + Hibernate/JPA que é uma solução que considero ser muito prática e uma excelente conjugação de tecnologias.
A característica técnica mais destacada são os DAOs genéricos que não requerem implementação. Para quem gosta de DAOs, pode ser bastante útil.
Para verem um site feito em Parancoe, podem consultar o JUGEvents que usámos para os registos no PTJUG.

Penso que qualquer uma destas últimas vale a pena uma voltinha

Quantas vezes não nos queixámos de esta ou aquela feature no nosso IDE favorito, sem no entanto fazer nada para a melhorar. Ou aquele plugin que gostavamos mesmo de ter.
A Sun criou a Netbeans Innovators Grant que permite que membros da comunidade open-source ganhem dinheiro vivo com contributos para o projecto Netbeans. O que a Sun ganha são novas features implementadas para a plataforma a um custo bastante baixo e uma visibilidade pela publicidade que isto dos prémios por desenvolvimento atrai. Aliás, a jetbrains, criadores do fantástico IntelliJ IDEA, fizeram o mesmo há algum tempo atrás com sucesso.

Resumidamente, serão atribuídas as seguintes bolsas:

• 10x bolsas de $11.500 cada, para projectos “grandes”
• 10x bolsas de $2.000 cada, para projectos menores
• 2x gold awards no valor de $11.000, para atribuir a 2 projectos dos 20 anteriores que tenham muito sucesso
• 2x silver awards no valor de $5.000, para atribuir a 2 projectos dos 20 anteriores que tenham sucesso

Para isto será necessário ter boas ideias. Uma vez escolhidas as 20 ideias, são atribuídas as bolsas às mesmas sendo que só se recebe o dinheiro no fim, se o projecto for concluído com sucesso. Ou seja, não será dinheiro fácil.

A submissão de propostas dura até dia 3 de Março. Podem consultar mais detalhes no site do Netbeans.

Mesmo para gajos do Eclipse como eu isto pode vir a ser motivador

Descobri a solução com o FEBE (Firefox Environment Backup Extension) [2].
Esta extensão do Firefox permite exportar e importar todas as extensões, temas, favoritos, preferências, password, cookies e tudo o resto.

Como o Wubi e o Windows estão na mesma máquina até pude utilizar o mesmo directório para a exportação de um sistema operativo e para importação no outro.

Louvai o FEBE.

Leituras

• [1] Experiência Wubi (http://www.zonaj.org/?p=70)
• [2] FEBE (Firefox Environment Backup Extension)
  (http://www.customsoftwareconsult.com/extensions/febe/febe.html)
  (https://addons.mozilla.org/en-US/firefox/addon/2109)

PS.
Já agora, a propósito de editores de texto: sou fã do Crimson Editor há alguns anos. Já tinha feito algumas tentativas de mudar sem sucesso, todos me pareciam sempre lentos a arrancar.
Estou a escrever isto com o Notepad++ e parece que tenho vencedor. Além de mais funcionalidades parece iniciar ainda mais rápido!

No Eclipse, por omissão, esta funcionalidade está configurada para as teclas Ctrl+F6.

Para alterarem a configuração deste atalho no Eclipse (Europa) eis o que devem fazer :

• Acedam ao menú do eclipse Window > Preferences
• Seleccionem na árvore General > Keys
• Substituam ‘type filter text‘ por ‘Next Editor‘
• Seleccionem a opção que surge na lista de resultados
• Seleccionem a caixa de texto Bindings e executem a combinação de teclas correspondentes ao atalho (Ctrl+Tab).
• Podem continuar a adicionar mais atalhos bastando para isso que carreguem em mais combinações de teclas (ou seja, podem manter o Ctrl+F6 original, caso pretendam)
• Confirmem as alterações e já podem usar o vosso novo atalho.

É claro que poderão usar este mesmo método para mudar outros atalhos do Eclipse.

1 – Criação da Base de Dados MySQL

Criem a base de dados com o nome lportal.

Poderão fazer isto utilizando o MySQL Administrator (a ferramenta de administração do MySQL) ou usando a seguinte linha de comando:
mysqladmin --default-character-set=utf8 create lportal

2 – Configuração do acesso à base de dados com o eclipse

Abram o Data Source Explorer do eclipse (Window -> Show view -> Data Source Explorer).

Seleccionem o icon ‘New Connection Profile’ ou usem o botão direito do rato do sobre ‘Databases’ e depois seleccionem ‘New’.

Na janela ‘New Connection Profile’ seleccionem o tipo SQL Model-JDBC Connection.

No quadro seguinte indiquem um nome para o perfil (ex: ‘Liferay – Mysql’).

No último quadro, usem o botão de procura (’…’) na lista “Select a browser”.

Adicionem uma nova definição:
• localizem o template para bases de dados MySQL na árvore (Database -> MySQL -> 5.0 -> MySQL JDBC Driver).
• Alterem as definições do driver:
  • Alterem o nome para ‘Liferay MySQL Driver’;
  • Removam o driver ‘default’ e adicionem um novo Jar correspondente ao ficheiro $WORKSPACE/ext/lib/development/mysql.jar ($WORKSPACE corresponde à localização da pasta do vosso workspace no sistema de ficheiros);
  • Configurem o valor das propriedades de acesso (username, password, etc…) tendo em atenção que o valor do ‘Database Name’ (e por consequência o final da linha do ‘Connection URL’ deverá ser ‘lportal‘.
• Confirmem as alterações e seleccionem agora este driver nas definições do driver (Database -> MySQL -> 5.0 -> Liferay MySQL Driver).

Voltem de novo à janela de criação do perfil e validem que todas as informações estão de acordo com a vossa configuração (podem testar a ligação a partir desta janela).

3 – Criação do modelo de dados

Editem o ficheiro create-mysql.sql na pasta /sql/create do projecto ‘ext’.
Caso não tenham memoria para desperdiçar (é o meu caso) respondam afirmativamente quando o eclipse perguntar se pretendem desligar a validação de sintaxe do ficheiro.

No topo da janela de edição do ficheiro encontram a configuração do ‘Connection profile’. Seleccionem o tipo Generic JDBC_1.x, o driver ‘Liferay - Mysql‘ e a base de dados lportal.

Nota: caso o status não seja ‘Connected‘ não vão conseguir ver o nome da base de dados.
Neste caso devem aceder ao Data Source Explorer ( Window -> Show View -> Data Source Explorer), seleccionar a Database ‘Liferay – MySQL’ e fazer connect (botão direito do rato)

Comentem as três primeiras linhas do ficheiro, uma vez que a base de dados já foi criada

-- drop database if exists lportal;
-- create database lportal character set utf8;
-- use lportal;

Gravem e executem o sql (ctrl+alt+X ou Execute All no menu contextual).

4 – Configuração do datasource no tomcat

Editem o ficheiro Root.xml localizado na pasta servers/tomcat/conf/Catalina/localhost do projecto ‘ext’.

Comentem o datasource do Hypersonic e descomentem o datasource do MySQL.

Preencham os atributos username e password e, caso não estejam a usar os valores default do MySQL, editem tambem o valor do atributo url, de acordo com a vossa configuração.

Gravem as alterações.

5 – Deploy da configuração para o servidor

Copiem o ficheiro Root.xml para a pasta conf/Catalina/localhost do tomcat.

Copiem e o ficheiro mysql.jar para para a pasta lib/ext do tomcat.

Voltarei a falar sobre a forma correcta de fazer deploy destes ficheiros no meu próximo artigo.

Resumidamente: Mesmo que tenham de usar jsf, não usem o jdeveloper. É um sanity killer! Era só mesmo este desabafo.

• seguimos o link permanente para a entrada (caixa ‘Posts Recentes’) e depois fazemos ‘back’ no browser;
• damos ao dedo a fazer scroll na página até que a entrada fique visível.

Uma forma interessante de resolver este problema seria ter uma opção de toggle do texto das entradas, ou seja, ter uma opção para mostrar ou esconder o texto dos posts por escolha do utilizador.

Estava a matutar sobre isto enquanto admirava os tons campestres desta página e pensei que não era má ideia pôr a solução em prática.

Um requisito importante é que o teria de fazer sem alterar efectivamente a página (só para não estar a chatear o Administrador do blog durante o fim-de-semana ).

Outro é que o código teria de ser suficiente pequeno para poder ser postado aqui.

Era definitivamente um bom desafio para por à prova o jQuery.

Precisava de quatro operações para concretizar as alterações:

1. esconder inicialmente o texto das entradas e os links para tags e comentários mas não o titulo ou a informação dos autores;
2. acrescentar à frente do nome do autor um link para permitir mostrar ou esconder o texto;
3. associar ao evento click do link uma função para concretizar a opção do utilizador;
4. desenvolver a função;

Usei o Firebug para analisar a estrutura do DOM da página.
Cada entrada tem uma estrutura fixa:

1. um <h2> com o link para o titulo;
2. um <h4> com a data do post e a identificação do autor;
3. um <div> com a class ‘entry’ com o texto;
4. um <p> com a class ‘tagged’ com links para as tags e comentários

Portanto, para concretizar a primeira operação só precisava de esconder os elementos com as classes ‘entry’ e ‘tagged’ que em jQuery se traduz como:
$('.entry, .tagged').hide();

Para a concretizar segunda operação acrescentei um link à frente do nome do autor, ou seja, de todos os <h4>s precedidos por <h2>s, ou em jQuery:
$('h2 ~ h4').append('<a href="javascript:void(0)" class="entryToggler">(Mostrar)</a>');

Para a terceira opção e visto que associei os links criados à class entryTogger, basta associar uma função ao evento onclick de todos os elementos com esta classe ou em jQuery:
$('.entryToggler').click(toggleEntry);

Falta só desenvolver a função toggleEntry.

Uma vez que esta função tem acesso ao elemento anchor seleccionado pelo utilizador (this), podia usá-lo como referência para:

1. verificar o estado da entrada a partir do texto:
   var isHidden = $(this).text().search('Mostrar')!=-1;
2. seleccionar os elementos correspondentes ao texto e aos links para as tags e comentários:
   var x=$(this).parent().next(); x = x.add(x.next());
3. mostrar ou esconder os elementos seleccionados:
   isHidden ? x.slideDown('slow') : x.slideUp('slow');
4. alterar o texto do link para ficar de acordo com a operação:
   isHidden ? $(this).text('(Esconder)') : $(this).text('(Mostrar)');

e estava feito!

Como podem testar o código? É fácil:
abram a página principal do blog. (pessoal do rss, tem mesmo que ser na página principal)

Se estiverem a usar o Firebug podem copiar o código completo para a consola e executarem-no:

var toggleEntry = function(){
	var isHidden = $(this).text().search('Mostrar')!=-1;
	var x=$(this).parent().next();
	x = x.add(x.next());
	isHidden ? x.slideDown('slow') : x.slideUp('slow');
	isHidden ? $(this).text('(Esconder)') : $(this).text('(Mostrar)');
};
$('.entry, .tagged').hide();
$('h2 ~ h4').append('<a href="javascript:void(0)" class="entryToggler">(Mostrar)</a>');
$('.entryToggler').click(toggleEntry);

Para os outros casos, escrevi o código todo numa só linha que podem copiar para a caixa de endereço do browser (substituindo o http://www.zonaj.org):

javascript:var toggleEntry = function(){var isHidden = $(this).text().search('Mostrar')!=-1;var x=$(this).parent().next();x = x.add(x.next());isHidden ? x.slideDown('slow') : x.slideUp('slow');isHidden ? $(this).text('(Esconder)') : $(this).text('(Mostrar)');};$('.entry, .tagged').hide();$('h2 ~ h4').append('<a href="javascript:void(0)" class="entryToggler">(Mostrar)</a>');$('.entryToggler').click(toggleEntry);void(0);

Testado com FF2, IE7 e Opera9.

É claro que tive a vantagem de não me ter de preocupar em importar o script de jQuery porque a própria página já o faz.
Caso estivesse a alterar o DOM de uma página que não use jQuery, podia fazer o mesmo tipo de alterações usando o jQuerify.

Nota 1:
Para deixar a primeira entrada sem alterações basta alterar a linha
$('.entry, .tagged').hide();
para
$('.entry, .tagged').not(':first').hide();
e a linha
$('h2 ~ h4').append('<a href="javascript:void(0)" class="entryToggler">(Mostrar)</a>');
para
$('h2 ~ h4').not(':first').append('<a href="javascript:void(0)" class="entryToggler">(Mostrar)</a>');

Nota 2:
Para remover a irritante ‘caixa picotada’ à volta do link quando este fica activo, acrescentar como ultima linha da função:
$(this).blur();

Nota 3:
O código final tem cerca de 10 (!) linhas e repeti-o 3 vezes neste post.

Nota 4:
Para ter de volta a página original basta fazer reload no browser (mesmo tendo alterado a linha de endereço).

• JSF é uma especificação

JSF é uma especificação e existem diversas implementações, sendo que a Sun fornece uma Reference Implementation. Por um lado, a especificação deixa pequenos detalhes de implementação à escolha dos implementadores e por outro, existem algumas falhas de desenho na especificação, assumidos inclusivamente por quem está a trabalhar na versão 2 do draft de especificação.

• Fases

O processamento JSF é dividido em 6 fases e é definida a ordem e o que ocorre em cada uma delas. O programador, em muitas situações, tem de ter a noção de fase presente quando está a programar, a desenvolver as suas acções, etc. Requer um conhecimento que apenas é adquirido com experiência e muitas falhas Aliás, tanto a noção de fases como as questões de request e sessão também deveriam ser o mais transparentes possíveis para quem desenvolve, deixando o programador dedicar-se a desenhar o interface e adicionar comportamento aos elementos do interface, como se fosse uma simples aplicação.

• Bugs

Historicamente, foram detectados alguns bugs graves nas implementações de JSF. Um dos exemplos é o do JSF gerar identificadores que já existiam declarados pelo utilizador na página, se foi resolvido passado meses.

• Identificadores Únicos

Temos de ter cuidado com identificadores duplicados e acaba-se por ter de se definir o id de cada componente da página. Obtemos um erro quando tentamos consultar a página e a origem do mesmo é não raras vezes difícil de depurar.

• Renderkit

Renderkits são um esquema falhado, no que toca a desenvolver para web. Em casos reais é quase impossível fazer output para múltiplos outputs sem alterar o conteúdo do jsf. Além disso, a geração de html está escondida dentro do renderkit e é difícil de controlar.

• Web Semântica e Acessibilidade

É muito difícil controlar o código que é gerado pelo JSF .
No mundo actual, quer-se markup semanticamente correcto, separação entre informação semântica (XHTML) e apresentação gráfica (CSS) e acessibilidade para utilizadores com necessidades especiais. Deve ser possível ter um controlo fino sobre o markup gerado. As interacções com os designers (mesmo com o meu post anterior não nos safamos) tornam-se mais complexas pois o programador não consegue replicar o código criado pelo designer.

• Manutenção de estado

Para manter o estado entre requests, o JSF fornece apenas a noção de sessão. Componentes como o SaveState do Tomahawk ou novas frameworks facilitadoras como o JBoss Seam permitem ter a noção de Conversation numa aplicação JSF. Se não forem utilizados estes componentes, o programador é obrigado a usar a sessão, caindo no erro comum de definir Managed Beans como de sessão quando tal não é adequado. Ou então colocando a informação do bean em sessão e recuperando-a quando necessário, no caso de beans de sessão. Ao usarmos estes esquemas de sessão não conseguimos, por exemplo, navegar em duas páginas da mesma aplicação ao mesmo tempo.

• ValueChangeListeners

Os eventos são processados mesmo quando não é esperado. Por exemplo, se tivermos uma dropdown com um ValueChangeListener e um valueBinding para uma nossa String, se submetermos a página sem alterar a dropdown, o evento será lançado porque o valor anterior da variável era null e o que é submetido é o valor default. Além disso, quando temos dropdowns com immediate=”true” e fazemos alterações no ValueChangeListeners, temos de saltar para fase de RenderResponse para que não tenhamos os dados reescritos. Duas palavras: mau desenho.

Estas são razões que chegue para não usar JSF. O que acontece em muitos casos, é usarem-se frameworks que tornem a tecnologia suportável, como sejam os componentes Tomahawk ou as frameworks Facelets e JBoss Seam.
Quando finalmente se chega à conclusão que existem outras frameworks que são melhores que JSF, encontramos coisas como o Tapestry ou o Wicket. Estas duas frameworks permitem-nos definir o interface com markup xhtml, conseguindo assim a desejada interacção com os designers e podendo, inclusivamente, fazer as nossas páginas directamente do protótipo.