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:

Segue abaixo os slides para quem não pode comparecer.

TheWebMind Tche Linux 2009

Quando vamos desenvolver um sistema precisamos inicialmente de um escopo. Após isso é feita a análise visando o sistema como um todo e por ai vai… Modelagem de banco de dados, Diagramas, Modelo de Classes etc.
Existem diversas metodologias, e cada sistema é único, porém muitas tarefas acabam se repetindo.

A proposta do TheWebMind consiste em minimizar ao máximo todas as tarefas repetitivas no desenvolvimento de um software.

Como ?

A equipe do TheWebMind explicará como no lançamento da segunda versão que ocorrerá neste sábado (17/11/09)  no TcheLinux 2009.
Para quem estiver em Porto Alegre fica aqui o convite.

Para quem não puder comparecer acesse o site:

http://thewebmind.org/

E aguardem que em breve tem site novo no ar!

Bom, nestes slides o Thomas aborda vários assuntos interessantes e úteis para todos nós programadores Javascript.
Ele da dicas do que deve ser evitado fazer, e o que é aconselhavel fazer em Javascript visando performance.
Para todos os exemplos de código ele fez um comparativo entre os browsers mostrando o tempo médio de execução em cada um, bem interessante.

Segue abaixo os slides, aproveitem:

A palestra conta um pouco da história do Javascript, explicando o porque do prefixo JAVA no nome da linguagem entre outros detalhes.
A palestra foca muito no desenvolvimento de Javascript profissional, como sugere o nome.

Espero que todos aproveitem. E qualquer dúvida, comentem ai.

Para quem assistiu a palestra e para quem não assistiu também, segue abaixo o link dos códigos utilizados:

http://jaydson.org/code/palestras/js-levado-a-serio/source.rar

Nota: Percebam que é somente no IE que isso acontece. Abaixo segue a lista de Browsers que suportam o evento change no Formulário:

Outra Nota: No IE o evento change também não é disparado nos objetos window e document. Em todos da lista acima sim.
Para o Internet Explorer o único elemento que dispara o evento change corretamente  é o <input>.

Solução:
Como o projeto estava utilizando jQuery foi simples resolver mais um problema no IE. Segue o código abaixo:

$("form *").bind("change", function(){ /* Código aqui*/});

O código acima varre todos elementos do formulário e “atacha” o evento change para cada um deles.

Bom, é isso.
Trabalhando e aprendendo.

Vamos a um exemplo simples de uma requisição Ajax:

$.ajax({
type: "POST",
url: "teste.php",
success: function(retorno){
alert(retorno);
}
});

Neste exemplo fazemos uma requisição Ajax e no sucesso damos um alerta do conteúdo retornado.
Mas e se der algum tipo de erro?
Vai de aplicação para aplicação, mas dependendo do caso podemos querer capturar o erro e fazer algum tratamento, ou simplesmente mostrar o erro.
Vamos agora ver um exemplo capturando o erro:

$.ajax({
type: "POST",
url: "teste.php",
success: function(retorno){
alert(retorno);
},
error: function(XMLHttpRequest, textStatus, errorThrown){
alert("Erro!");
}
});

Agora capturamos o erro e damos um alerta de erro caso ocorra falha na requisição.
Agora para ficar pouco mais útil, vamos ver as propriedades e métodos do objeto XMLHttpRequest.
Basta fazer um “for in” no objeto que conseguimos pegar todas suas propriedades. Abaixo listo algumas:

dispatchEvent()
removeEventListener()
open()
setRequestHeader()
send()
readyState
status
channel
responseXML
responseText
statusText
abort()
getAllResponseHeaders()
getResponseHeader()

Caso queiram fazer o teste e varrer o objeto e ver suas propriedades:

for(i in XMLHttpRequest){
if(i!="channel")
document.write(i +" : " + XMLHttpRequest[i] +"<br>")
}

OBS:
Este filtro testando se a propriedade é “channel” é necessário, pois o browser gera uma exceção de permissão negada para ler essa propriedade.

Bom, com isso já da pra ter uma boa noção sobre como capturar erros Ajax, agora o que fazer com eles é com vocês.
Usei bastante esta técnica na manipulação de Ajax no projeto TheWebMind.org, e em alguns outros sistemas.
Estou preparando um plugin para o jQuery que auxiliará bastante.
Segue uma prévia do que já implementei abaixo:

error: function(XMLHttpRequest, textStatus, errorThrown){
$(XMLHttpRequest).AjaxDebug({
containerId : 'load',
nativeConsole : false
});
}

A idéia é fornecer um console que mostre estas informações, ou passar as informações para um determinado elemento.
Em breve posto aqui quando estiver pronto!

E claro, não vamos esquecer do Firebug que é um excelente debugador para Ajax também.