include('Zend/Loader.php');
Zend_Loader::registerAutoload();

Para solucionar o problema basta usar o Zend_Loader_Autoloader.
Em minha implementação apenas o trecho abaixo resolveu o problema:

include('Zend/Loader/Autoloader.php');
$autoloader = Zend_Loader_Autoloader::getInstance();

function _(i,m,callback){
     setTimeout(function(){
       return i>1?_(--i,m,callback):false;
    },m);
    callback(i);
}

Simples, não?
Mais abaixo vou explicar o que acontece.
Com essa função é possível fazer implementações deste tipo:

/*
   Irá executar 5 vezes no intervalo de 500 milisegundos a função anônima abaixo.
*/
_(5,500,function(){
        // XHR buscando um JSON
	$.getJSON('sample.json',function(jsonObject){
		console.log(jsonObject);
	});
});

/*
   Irá executar 44 vezes no intervalo de 1 segundo a função anônima abaixo.
*/
_(44,1000,function(){
       console.log('X');
});

Bom, esta função resolveu um problema específico que enfrentei, e resolvi posta-la para quem possa precisar um dia.
Mas o interessante é sua implementação em poucas linhas e sua recursividade.

Explicação:
Notem que a função recebe 3 parâmetros (i,m,callback) onde:
i = Quantidade de vezes que a função deve ser executada
m = Intervalo em milisegundos
callback = Função a ser executada

A primeira ação da função é executar o setTimeout() passando a função e os milisegundos.
Logo uma operação ternária para verificar se a quantidade é maior que 1. Porque isso?
Porque para economizar variáveis auxiliares e outras possíveis complicações, o que fiz foi decrementar a quantidade de vezes, ou seja, se a função deve ser executada 5 vezes, começo em 5 até chegar a 1.
Se ainda é maior então chamamos a mesma função recursivamente, e claro, decrementando a quantidade de vezes.
OBS: O decremento à esquerda (–i) faz com que a variável i seja decrementada antes de ser passada para a função.
A cada chamada, a função passada é executada e ainda devolve o índice atual para possível manipulação.

Enfim, esta foi minha solução, caso consigam desenvolver outra, ou já tenham feito algo parecido, postem ai!

Mas hoje venho falar de uma possibilidade muito interessante que mais uma vez devo a  dica ao Ricardo Tomasi, que é a customização de expressões.
Uma rápida pesquisa no Google e voces encontraram varios posts espalhados pelo mundo falando a respeito.
Customizar uma expressão consiste em incorporar ao jQuery um método que ele não possui nativamente.

Mas porque diabos fazer isso?
Acreditem, pode ser bem útil.

No curso de jQuery que estou ministrando na Target Trust, ontem bolei um exercício simples para os alunos:

“Mude a cor de fundo de todas as TD’s com indice ímpar da tabela com id tabela2″

Sacaram a ideia?
Simples. O que eu queria, é que eles fizessem da maneira deles, usando um loop, verificando o mod do indice e assim aplicar o css no elemento, para então depois apresentar o seletor odd que faz exatamente isso, só que em uma linha.

$(“table td:odd”).css(“background-color”, “#bbbbff”);

Tudo tranquilo, mas um dos alunos muito antenado achou o seletor e resolveu o problema facilmente!
Então mudei a estratégia, e pedi para ele implementar um algoritmo que apenas aplicasse o estilo nas TD’s com indice que fosse número primo.
Novamente o aluno conseguiu.
Foi ai que lembrei da possibilidade de customização das expressões!
Fiz a proposta para o aluno: Se tu conseguir criar uma expressão customizada que retorne elementos baseando-se nos numeros primos terá um post no meu blog!
Então ai esta. Abaixo segue o código implementado pelo aluno Andre Pinto da turma de jQuery Maio/2010:

jQuery.extend( jQuery.expr[':'], {
	prime: function(a, index){
		function isPrime(num){
			var numHalf = num / 2, counter, divCheck;
				if (num === 2){
					return true;
				}
				if (num < 2 || numHalf === Math.floor(numHalf) ||
                                   num !== Math.floor(num)){
					return false;
				}else{
					for (counter = 3; counter <= Math.sqrt(num);
                                              counter += 2){
						divCheck = num / counter;
						if (divCheck === Math.floor(divCheck)) {
							return false;
						}
					}
				return true;
			       }
		}
           return isPrime(index);
     }
});

Para usar a expressão:

$('#tabela2 td:prime').css( { 'background-color' : 'red' } );

Parabéns ao André pela implementação.

Se você tem R$20,00 e me dá R$20,00, no final, eu tenho R$20,00 e você não tem mais nada.

Se você sabe um teorema e me ensina, ao final eu tenho o teorema, mas você o conserva também.

Então, o conhecimento não obedece às leis da troca mercantil, ele tem mesmo a virtude

de fazer exatamente o oposto…Em vez de um jogo de resultado nulo, ele suscita a multiplicação

do seu valor.

Michel Serres

A instalação do node não é nada complexa, porém exige alguns cuidados.
Estou no Ubuntu, e seguindo as instruções do site, de primeira não funcionou.
Agradeço aqui ao Ricardo Tomasi pelas dicas sobre a instalação do node.  ;)

São poucos passos, abra o terminal e  execute estes simples comandos:

./configure
make
make install

Se tudo funcionou, ou seja, não acusou nenhuma falha [FAIL] é porque o nodeJS foi instalado corretamente.
No meu caso a falha ocorreu porque eu não tinha nenhum compilador GCC e G++.
Bastou abrir o Synaptic, selecionar a categoria Development, procurar por G++ e pronto.
G++ instalado agora o próximo passo é executar:

sudo make test

Feito. Agora vamos criar um clássico Hello World com o node.
Parto do princípio que tudo deu certo até aqui, e que o node está instaldo e pronto pra usar.
Crie um arquivo Javascript com o seguinte conteúdo:

var sys = require('sys'),
http = require('http');
http.createServer(function (req, res) {
        setTimeout(function () {
               res.writeHead(200, {'Content-Type': 'text/plain'});
               res.write('Hello World');
               res.close();
        }, 2000);
}).listen(8000);
sys.puts('Server running at http://127.0.0.1:8000/');

Salve o arquivo com o nome que desejar dentro da pasta test que foi criada na raiz do node.
Para testar:

node nome_do_seu_arquivo.js

A mensagem no terminal deve ser essa: “Server running at http://127.0.0.1:8000/“

Acesse com o Browser o endereço para visualizar a aplicação Hello World em funcionamento.

Bom, com a breve introdução e com esse exemplo é possível ter uma ideia do que é nodeJS. O próximo passo é estudar a Documentação que é bem rica.
Fico por aqui, qualquer dúvida entrem em contato que tentarei ajudar.

Há tempos que penso em testar o nodeJS, mas só esta semana pude parar e dedicar um pouco de tempo a este obejtivo.
Meu intuito com este post é apenas “compilar” algumas informações sobre o node e passar adiante para aqueles que ainda não tiveram a oportunidade de conhecer.
O que mais me motivou a investigar o node, foi o próprio nome. nodeJS.
Assim como todo aficcionado por Javascript, sempre quero saber tudo a respeito da linguagem, assim como o que está sendo feito com ela.
O que mais me chamou a atenção foi o termo: “Server-side Javascript“. \o/
Sim, isso mesmo. Javascript rodando no servidor.
O que me expantou também foi o fato de existirem várias implementações deste tipo, são quase 50 [Link acima].

Vamos então as características do nodeJS:

Interessado em aprender mais assim como eu?
Então, algumas referências:

Site do nodeJS
http://nodejs.org/#about

Módulo para rodar YUI dentro do node
http://yuilibrary.com/gallery/show/nodejs

Blog do Simon Willison falando sobre nodeJS

Slides JSConf
http://s3.amazonaws.com/four.livejournal/20091117/jsconf.pdf

Aplicação exemplo com o node
http://chat.nodejs.org/

Vídeo com Ryan Dahl falando sobre o node em SãoFrancisco em janeiro deste ano

NodeJS Synoposis from Kris Kowal on Vimeo.

No próximo post mostrarei  um passo a passo de como instalar o nodeJS e como fazer um “Hello World”.  :P

Atualmente o TheWebMind encontra-se na versão Pre-Alpha, isso quer dizer que ainda não está totalmente estável, ainda possui bugs e melhorias a serem implementadas.
Mas com o que temos hoje, é possível fazer muita coisa. E é isso que quero compartilhar.

Parto do princípio que quem estiver seguindo o tutorial já saiba o que é o TheWebMind, e conheça a teoria por traz de tudo.
Caso contrário acesse a página da documentação: http://docs.thewebmind.org/index.php?title=Main_Page

Minha proposta é criar um sistema simples de tarefas.

Requisitos:
O sistema deve permitir o cadastro de usuários.
O usuário deve ter nome.
A tarefa deve possuir título, descrição, data e um usuário vinculado.
O sistema deve permitir o cadastro de várias tarefas para um usuário.
O sistema deve possuir interface para edição e visualização dos dados, tanto de usuários como de tarefas.
Resumindo, é um sistema bem simples, onde o usuário cadastra suas tarefas.

Passo 1 – Criando um projeto no TheWebMind

Para criar um projeto, acesse o menu File > New Project e preencha os dados do projeto.
OBS: Certifique-se de que você tem um banco de dados instalado e configurado  no seu server, e preencha corretamente os dados, informando o endereço, nome, porta, usuário e senha do banco de dados.
São estas informações que o TheWebMind utiliza para gerar as tabelas.

Passo 2 – Escrevendo em WML

Criado o projeto, vamos escrever o código WML que atenda aos requisitos.
A sintaxe da linguagem WML é baseada no conceito NLP (Natural Language Processing), que consiste basicamente em ser semelhante a linguagem humana natural(Português, Inglês, Espanhol, etc).
Veja mais detalhes na documentação: http://docs.thewebmind.org/index.php?title=Web-Mind-Language

<br /><br />Sabemos que o usuario tem nome:string(100);<br />A tarefa tem título:string(100);<br />A tarefa tem descrição:text();<br />A tarefa tem data:date();<br />O usuario tem tarefa;<br /><br />

Passo 3 – Visualizando as saídas

Clique no botão localizado na barra de tarefas acima do editor.

Depois de “compilado” o projeto, você poderá ver as saídas como diagrama ER, Dicionário de dados, e o código SQL no painel de abas logo abaixo do editor.

Passo 4 – Gerando o projeto

Para gerar o projeto clique  no botão também localizado na barra de tarefas acima do editor.
Uma tela de Wizard abrirá, guiando o usuário até o final.
No Step 1 selecione a segunda opção, que indica o banco de dados de desenvolvimento previamente cadastrado na tela de criar o projeto.
Avance para o próximo passo clicando no botão Next.
Uma tela com todos os módulos será exibida no Step 2, selecione o ZendModels e avance para o próximo passo.
No Step 3 existem 2 opções relacionadas ao que o TheWebMind irá fazer em relação ao banco de dados.
Esta opção deve ser cuidadosamente selecionada, pois se você selecionar a opção “be replaced” , o TheWebMind irá deletar a tabela existente, assim como todos os seus dados e criará uma nova com as alterações necessárias.
A opção “be skipped” ignora qualquer alteração na base de dados.
Agora clique em Finish, e acompanhe a tela onde o TheWebMind mostra tudo que está acontecendo, como cópia de arquivos necessários, criação de tabelas, etc.

Pronto. Você acabou de criar um sistema com o TheWebMind.

Passo 5 – Visualizando o projeto gerado

Feito todo o trabalho, o TheWebMind irá exibir a mensagem “Finished, the project’s been generated here“.
Uma tela com a arvore de arquivos gerados será exibida. É possível ver o conteúdo de um arquivo ao seleciona-lo.
Acima da árvore, clique no botão “Explore Files” , este o conduzirá até a página onde a Aplicação foi gerada.

Passo 6 – Testando a Aplicação

Seguindo esses passos temos um simples sistema de tarefas funcionando.
Para testar publiquei a aplicação gerada aqui: http://source.jaydson.org/TaskList/
O ZendModels gera os formulários da aplicação, isso serve para testarmos se tudo esta funcionando corretamente.

Bom, este foi um pequeno tutorial de como fazer um sistema simples com o TheWebMind utilizando o ZendModels.
Qualquer dúvida entrem em contato ou comentem.
Abaixo segue o link para download da aplicação gerada no exemplo, mas para um melhor entendimento do TheWebMind sugiro que vocês façam o download do TheWebMind, e sigam todos os passos descritos acima.
É muito fácil.

Download:  http://source.jaydson.org/TaskList.rar

Vejam um outro exemplo no blog do @felipenmoura : http://felipenascimento.org/en/portugues-brasil-criando-uma-aplicacao-funcional-com-thewebmind/

O projeto vem crescendo ao longo dos meses, e 2010 promete ser um ano de muito sucesso.
Desenvolvedores espalhados pelo Brasil e pelo mundo estão entrando em contato conosco mostrando interesse em participar de alguma maneira do TheWebMind.
Aos poucos estamos nos organizando e selecionando pessoas engajadas que possam contribuir.

Semana passada foi um marco para o TheWebMind. Finalmente depois de muito trabalho, liberamos a versão Pre-Alpha 2.0.0.
Está versão esta totalmente diferente da 1° versão lançada em 2009.
Reescrevemos praticamente todo o core e reformulamos totalmente a interface.
Construímos um novo módulo(ZendModels) que gera código PHP baseado no Zend Framework.

Bom, aos interessados segue abaixo o link para download:
http://thewebmind.org/download_latest

Nas próximas semanas pretendo postar exemplos práticos de uso do TheWebMind,  principalmente usando o ZendModels para geração de código.

A linguagem se assemelha muito com a natural (português, inglês, espanhol, etc.), apenas seguindo algumas regras de sintaxe.
Este padrão, chamamos de Linguagem de Programação Discreta.
Em uma linguagem de programação discreta, as instruções são totalmente variáveis podendo inclusive sofrer alterações durante seu uso, ou por conta de costumes do próprio usuário, bem como idioma, dialeto, crenças, etc.

Um dos princípios mais básicos das linguagens de programação é que “tudo aquilo que não está certo, está errado”.
Já no conceito de programação discreta, nem tudo que não é reconhecido pela linguagem, está necessariamente incorreto.
Esta margem de erro possibilita tanto ao desenvolvedor, adaptar-se melhor à linguagem, quanto à própria linguagem de se adaptar e evoluir.

Programar em WML é extremamente simples, observem o exemplo abaixo:

Bom, nós sabemos que cada professor pode ter um ou mais aluno

também sabemos que todo aluno possui muitos professor

nos foi passado que o aluno tem um nome:string(100)

e que o professor possui um nome:string(100)

De primeira olhando o código temos a impressão de que algo esta estranho, não?
Pois é asim mesmo que tudo funciona.
O príncipio é escrever o código de maneira natural, como se estivéssemos documentando o projeto, ou apenas escrevendo sobre ele.
Feito isso, a engine do Mind irá aplicar uma série de regras em cima do código, e interpretará o conhecimento que lhe foi passado.

Com o código acima, o Mind consegue gerar diversas saídas como Diagrama de Entidade e Relacionamento, Dicionário de Dados, Código SQL, e até mesmo gerar código usando um módulo específico.
Abaixo algumas das saídas:

Código SQL gerado pelo código feito acima:

/*######################################################
 #   Generated by Mind 02:58 11/19/2009               #
 #   Generate PostgreSQL DataBase Commands         #
 ######################################################*/

 /* DDL: table professor */
CREATE SEQUENCE professor_seq;
CREATE TABLE professor
(
 pk_professor integer default nextval('professor_seq') unique not null,
 nome varchar(100),
 PRIMARY KEY(pk_professor)
);

 /* DDL: table aluno */
CREATE SEQUENCE aluno_seq;
CREATE TABLE aluno
(
 pk_aluno integer default nextval('aluno_seq') unique not null,
 nome varchar(100),
 PRIMARY KEY(pk_aluno)
);

 /* DDL: table professor_aluno */
CREATE SEQUENCE professor_aluno_seq;
CREATE TABLE professor_aluno
(
 pk_professor_aluno integer default nextval('professor_aluno_seq') unique not null,
 fk_professor integer  ,
 fk_aluno integer  ,
 PRIMARY KEY(pk_professor_aluno)
);

 /* Adding Foreign Keys */
ALTER TABLE professor_aluno ADD CONSTRAINT professor_aluno_professor FOREIGN KEY (fk_professor) REFERENCES professor(pk_professor) MATCH FULL;
ALTER TABLE professor_aluno ADD CONSTRAINT professor_aluno_aluno FOREIGN KEY (fk_aluno) REFERENCES aluno(pk_aluno) MATCH FULL;

Diagrama ER:

Digrama ER

Abaixo segue um vídeo curto que mostra como porgramar WML utilizando a IDE do Mind:

Por hoje é isso.

Em breve mais posts sobre esta incrível ferramenta.
Por enquanto acessem o site e a documentação:

Docs.TheWebMind.org
TheWebMind.org

Juntamente com o Felipe Nascimento, palestrei na Target Trust (empresa de TI especializada em treinamentos aqui em Porto Alegre)  nesta terça-feira(17/11/2009) sobre a biblioteca jQuery.
O objetivo da palestra foi introduzir o jQuery de maneira que os ouvintes pudessem compreender o poder da biblioteca e do Javascript em si.
Quem teve a oportunidade de acompanhar a palestra conheceu um pouco da história do jQuery, sua origem e também ver as inúmeras possibilidades e funcionalidades.

Abaixo então seguem os slides: