O que é Template Engine?

Template Engine (motor de template) é um processo, parte de um software ou um software, capaz de receber um ou mais documentos formatados, um ou mais modelos de dados, compilá-los e retornar um ou mais documentos de saída.
De forma bem simples, o template engine é a parte de um programa responsável por pegar um arquivo de modelo (template), que representa a saída do programa e preenchê-lo com dados da execução atual, retornando o documento final para o usuário.
Logo, tem-se que o código de processamento (Controller) está separado do código da visualização (View), podendo assim alcançar o padrão de arquitetura MVC.

O que é Smarty Template Engine?

Existem várias Template Engines para várias linguagens de programação. Inclusive, vários frameworks, como o Django (para Python) possuem sua própria engine.
PHP, como linguagem, não é diferente e possui um conjunto de aplicações do tipo Template Engine. Dentre essas aplicações existe o Smarty.
Smarty é a Template Engine mais popular para PHP, e me atrevo a dizer que Smarty é a template engine mais popular dentre todas as template engines de todas as linguagens.
Basta tentar uma busca no Google pelo termo template engine, e você verá logo após o artigo do Wikipedia quem aparece.
Também, o projeto Smarty existe desde 2002, o que dá uma certa credibilidade em relação as engines mais novas.

Utilizo o Smarty desde que o vi pela primeira vez, em 2006.
Desde então, não sei programar PHP sem utilizá-lo!
As vezes procuro novas templates engines para não ficar preso/bitolado no Smarty, mas para PHP nenhuma engine conseguiu chamar minha atenção.

Por que usar uma template engine?

O primeiro motivo é querer separar o código HTML (ou outra forma de saída do seu script) do seu código PHP é evitar o código spaghetti, que é quando tem-se aquela bagunça de, no mesmo arquivo (código-fonte) termos PHP-Html-JavaScript-CSS, tudo junto e misturado, o que é bem comum no mundo PHP (MAS NÃO DEVERIA SER COMUM!)

O segundo motivo é a manutenção.
Quando utilizamos uma template engine, separando o código-fonte (controller) do layout(view), podemos fazer várias alterações no layout final sem nem sequer precisar abrir o arquivo do código fonte.
Por exemplo, levem em consideração o WordPress. Ele separa o código da plataforma de blog do código do layout. Podemos então alterar várias vezes o layout do blog sem nem sequer abrir o código fonte da plataforma de blog.
Porém, o WordPress não usa uma template engine. O que ele faz é importar e executar arquivos PHP que definem o layout.

O terceiro motivo é trabalhar com designers.
Na facilidade (e problema) citado no exemplo do WordPress, o nosso caro designer teria que aprender a programar em PHP para conseguir fazer um layout.
Não é legal.
Sem querer ofender ninguém, mas designers não estudam para isso e podem não ter uma “mente lógica e algorítmica” que muitos programadores possuem. Claro que existem exceções, e temos por ai grandes designers-programadores.
Mas, quando trabalhamos em uma equipe de desenvolvimento, queremos manter cada membro focado na sua atividade. Ter que fazer o designer aprender PHP ou ter que migrar o layout de HTML para PHP pode representar perca de foco, tempo e dinheiro.
Para isso, as template engines implementam pequenas funções chaves (tags), como loops para preencher os options dentro de um campo select.
O designer não precisa aprender a programar. O que ele precisa é conhecer as tags da template engine, que são poucas, e conhecer o nome das variáveis que virão do código-fonte, que pode ser definido na documentação do projeto.

Smarty Template Engine: Usar ou não?

Agora podemos responder a pergunta feita no post desse artigo.

Se você acredita que seu projeto precisa atingir pelo menos 1 dos três pontos supra-citados e este será programado em PHP, você é um forte candidato a utilizar o Smarty.
Você pode optar por usar outra template engine, mas para finalizar este artigo, e responder a pergunta Smarty Template Engine: Usar ou não? gostaria de citar alguns pontos que me fizeram escolher esta ferramenta e que me fazem permanecer com ela por 6 anos consecutivos.

• Eficiência – quem faz o trabalho é o PHP.
  Um das tarefas executadas pelo Smarty é traduzir o seu template para PHP. Logo, seu template é analisado pelo PARSER do PHP, o que torna a tarefa Smarty simples e rápida.
• Sem Retrabalhos – Smarty não possui overhead.
  Em sua primeira execução, o template é traduzido para PHP, análisado pelo parser do PHP e salvo. Nas futuras execuções, basta executar o arquivo PHP gerado em conjunto com os dados passados pela aplicação.
  Assim, não existe o retrabalho de sempre executar a operação de tradução e PARSER do template.
  Smarty percebe se seu template foi modificado e, então, o recompila.
• Cache – Com cache, não há retrabalho.
  O template é compilado e salvo junto com os dados da execução para ser reutilizado sem precisar ser TRADUZIDO, PARSEADO, COMPILADO JUNTO COM OS DADOS.
  Basta apenas ser exibido para o usuário.
  Simples assim.
• Herança de Templates – Uma forma simples e intuitiva de reutilizar códigos de template no seu projeto.
  Assim, escrevendo menos e produzindo mais!
  Herança de Templates é uma idéia nova, muito bem utilizada no Django.
• E MUITO MAIS! – Parecendo um vendedor de itens pela tv, mas é verdade!
  Tags customizáveis, delimitadores, um conjunto de tags úteis que fazem muito em apenas uma linha, capacidade de plugins, facilidade de tornar um template internacionalizado (vários arquivos de lingua, um arquivo de template), etc

E ai, vai usar ou não?

O Modelo:

Desenhei um banco simples que atende a necessidade do projeto, o sistema de enquetes.
Caso tenham interesse em saber, utilizei a ferramenta MySQL Workbench para desenhar o modelo do banco.

Desse modelo, utilizando a própria ferramenta MySQL Workbench, pude gerar o seguinte código SQL para a criação do banco de dados:

-- -----------------------------------------------------
-- Table `usuario`
-- -----------------------------------------------------
CREATE  TABLE IF NOT EXISTS `usuario` (
  `id` INT UNSIGNED NOT NULL AUTO_INCREMENT ,
  `login` VARCHAR(20) NOT NULL ,
  `senha` VARCHAR(32) NOT NULL ,
  `nome` VARCHAR(80) NOT NULL ,
  `email` VARCHAR(80) NOT NULL ,
  PRIMARY KEY (`id`) )
ENGINE = InnoDB;

-- -----------------------------------------------------
-- Table `permissao`
-- -----------------------------------------------------
CREATE  TABLE IF NOT EXISTS `permissao` (
  `id` INT UNSIGNED NOT NULL AUTO_INCREMENT ,
  `descricao` VARCHAR(45) NOT NULL ,
  PRIMARY KEY (`id`) )
ENGINE = InnoDB;

-- -----------------------------------------------------
-- Table `usuario_permissao`
-- -----------------------------------------------------
CREATE  TABLE IF NOT EXISTS `usuario_permissao` (
  `usuario_id` INT UNSIGNED NOT NULL ,
  `permissao_id` INT UNSIGNED NOT NULL ,
  PRIMARY KEY (`usuario_id`, `permissao_id`) ,
  INDEX `fk_usuario_has_permissao_permissao1` (`permissao_id` ASC) ,
  INDEX `fk_usuario_has_permissao_usuario` (`usuario_id` ASC) ,
  CONSTRAINT `fk_usuario_has_permissao_usuario`
    FOREIGN KEY (`usuario_id` )
    REFERENCES `usuario` (`id` )
    ON DELETE CASCADE
    ON UPDATE CASCADE,
  CONSTRAINT `fk_usuario_has_permissao_permissao1`
    FOREIGN KEY (`permissao_id` )
    REFERENCES `permissao` (`id` )
    ON DELETE CASCADE
    ON UPDATE CASCADE)
ENGINE = InnoDB;

-- -----------------------------------------------------
-- Table `enquete`
-- -----------------------------------------------------
CREATE  TABLE IF NOT EXISTS `enquete` (
  `id` INT UNSIGNED NOT NULL AUTO_INCREMENT ,
  `titulo` VARCHAR(45) NOT NULL ,
  `descricao` VARCHAR(45) NULL ,
  `inicio` DATETIME NOT NULL ,
  `usuario_id` INT UNSIGNED NOT NULL ,
  PRIMARY KEY (`id`) ,
  INDEX `fk_enquete_usuario1` (`usuario_id` ASC) ,
  CONSTRAINT `fk_enquete_usuario1`
    FOREIGN KEY (`usuario_id` )
    REFERENCES `usuario` (`id` )
    ON DELETE CASCADE
    ON UPDATE CASCADE)
ENGINE = InnoDB;

-- -----------------------------------------------------
-- Table `opcao`
-- -----------------------------------------------------
CREATE  TABLE IF NOT EXISTS `opcao` (
  `id` INT UNSIGNED NOT NULL AUTO_INCREMENT ,
  `titulo` VARCHAR(45) NOT NULL ,
  `descricao` VARCHAR(100) NULL ,
  `enquete_id` INT UNSIGNED NOT NULL ,
  PRIMARY KEY (`id`) ,
  INDEX `fk_opcao_enquete1` (`enquete_id` ASC) ,
  CONSTRAINT `fk_opcao_enquete1`
    FOREIGN KEY (`enquete_id` )
    REFERENCES `enquete` (`id` )
    ON DELETE CASCADE
    ON UPDATE CASCADE)
ENGINE = InnoDB;

-- -----------------------------------------------------
-- Table `voto`
-- -----------------------------------------------------
CREATE  TABLE IF NOT EXISTS `voto` (
  `usuario_id` INT UNSIGNED NOT NULL ,
  `opcao_id` INT UNSIGNED NOT NULL ,
  `hora` DATETIME NOT NULL ,
  PRIMARY KEY (`usuario_id`, `opcao_id`) ,
  INDEX `fk_usuario_has_enquete_usuario1` (`usuario_id` ASC) ,
  INDEX `fk_usuario_has_enquete_opcao1` (`opcao_id` ASC) ,
  CONSTRAINT `fk_usuario_has_enquete_usuario1`
    FOREIGN KEY (`usuario_id` )
    REFERENCES `usuario` (`id` )
    ON DELETE CASCADE
    ON UPDATE CASCADE,
  CONSTRAINT `fk_usuario_has_enquete_opcao1`
    FOREIGN KEY (`opcao_id` )
    REFERENCES `opcao` (`id` )
    ON DELETE CASCADE
    ON UPDATE CASCADE)
ENGINE = InnoDB;

Entendendo o Modelo

A primeira tabela a ser analisada é a tabela usuario. Nela definimos o usuário do sistema. Moleza, certo?

A segunda tabela a ser analisada é a tabela permissao. Nela definimos as permissões que existem dentro do sistema.
Permissões como “adicionar ou excluir usuário” ou “extrair relatórios”, e por ai vai.

Logo, já podemos entender a tabela usuario_permissao, que definie as permissões que foram dadas a um usuário.
Dessa forma pode-se criar uma forma bem simples de se distribuir permissões dentro de um sistema.

em seguida podemos analisar as tabelas enquete e opcao.
Na primeira, ficam alguns dados do cabeçalho de uma enquete, enquanto na segunda ficam todas as opções passiveis de serem selecionadas naquela enquete.

Por fim, temos a tabela voto, que associa o usuário a uma opção.
Assim sabemos qual foi a opção escolhida por um usuário em uma enquete.

O que vem a seguir?

Programaaaaaaaaar!!!

Programo com PHP a um pouco mais que 5 anos.
Como gosto de construir projetos sólidos que dependam muito pouco de códigos externos, sempre abominei a utilização de frameworks.
Nas minhas aplicações a única biblioteca que não era desenvolvida por mim e nem pela minha equipe era o Smarty Template Engine. Também pudera, depois que conheci o Smarty passei a achar ser impossível fazer um bom projeto sem utilizá-lo.
Na primeira empresa que trabalhei conheci o Propel, um ORM para PHP. Uma bela mão na roda, mas isso era 2006. Na época o PHP5 ainda era tido como novidade, e o danado do Propel as vezes apresentava uns bugs esquisitos e aleatórios, por isso parei de utilizá-lo.

Frameworks e Python:

Ultimamente tenho brincado bastante com Python e web.
Podem descordar de mim, mas acredito que hoje em dia é praticamente impossível achar um projeto Python para web que não utilize um framework.
Existem muitos frameworks para colocar seu código Python na web. Todos são muito robustos, cheios de bibliotecas e facilidades incorporadas, sem contar que grande parte ainda aceita plugins externos de forma fácil.
São tantos frameworks que eles são divididos em categorias como, por exemplo, os micro-frameworks, que fazem o básico que é ajudar a por o servidor no ar e antender as requisições GET e POST, ou os full-stack frameworks, que fazem de tudo. LITERALMENTE TUDO! ORM, Views, Url Dispatcher, Forms, Template engines etc.

Por que PHP e não Python:

Python é uma linguagem realmente legal e que faz com que o programador sinta prazer em programar.
Mas tenho uma maior fluência e experiência com o PHP e ainda prefiro trabalhar web com PHP. Pode ser que isso mude um dia, mas por enquanto, na minha opinião, programar para a web é sinônimo de PHP.
Também tem o fato de que ninguém ainda conseguiu me convencer que, no tocante desempenho, Python é melhor que PHP, quando falamos de aplicações WEB.
Por isso decidi que iria aprender um ou dois frameworks para PHP e que iria começar a usá-los daqui para frente. Quem sabe não encontro algo tão legal quanto Django?

PHP e os vários frameworks:

Foi ai que percebi que a comunidade PHP cresceu bastante nesses últimos anos, e que frameworks que eu ouvia falar que estavam em fase alpha hoje são os top-pica das galáxias.

Li vários artigos, conversei com alguns amigos e pesquisei bastante.
Existem boas opções mas existem poucas comparações.
Assim fica realmente difícil escolher um framework.
A solução é aprender e testar um por um e então adotar um ou dois para serem os meus “frameworks oficiais”.
Claro que não vou largar minha mania de programar sem frameworks. Mas, as vezes, pode ser que um projeto tenha um prazo muito curto, e frameworks ajudam bastante nessas horas.

A Experiência:

Para me ajudar a comparar os frameworks irei construir com cada um deles a mesma aplicação.
O pequeno projeto é um sistema de votação, onde os usuários podem criar uma nova enquete, com suas respectivas opções, votar e ver resultados.

É um projeto bem simples, que envolve CRUD no banco de dados, visualização, formulários, logins e permissionamento.

Julgando os frameworks:

Para poder decidir qual, ou quais, framework(s) vou utilizar, preciso definir como vou julgá-los.
As notas serão de 0 a 10 para cada quesito que for por mim analisado.
Por enquanto os quesitos que acredito que vou utilizar para a analise são:

• Manuais, docs e tutoriais – Quanto mais fácil for para achar formas de aprender e tirar dúvidas, melhor
• Facilidade de aprendizado, entendimento e uso
• Liberdade de paradigma – As vezes você quer usar POO e as vezes não.
• Templates – Quanto mais fácil de utilizar e legível for o template, melhor
• MVC – O MVC é pré-requisito
• Multiplos bancos e ORM – Pelo menos MySql e Postgre
• Validação e segurança – O framework deve ajudar bastante!
• logins, auths e sessions
• DRY – Don’t Repeat Yourself
• Url Dispatcher – Url Routing
• Licença de uso
• Feeling – O quão bem me sinto programando com esse framework

Concorrentes:

Aproveitando o embalo de estar metendo a mão na massa para fazer análises de frameworks, analisarei também os dois principais projetos de PHP ORM, o Propel e o Doctrine.

• PHP + Smarty – O basicão de cada dia, utilizando o PDO
• PHP + Smarty + Propel – O basicão com a ajuda de um ORM, primeiro round
• PHP + Smarty + Doctrine – O basicão com a ajuda de um ORM, segundo round
• Framework CakePhp
• Framework CodeIgniter
• Framework Zend
• Framework Yii
• Framework Symfony
• Framework Akelos
• Framework Kohana
• Framework DooPHP

Desenvolvimento:

Tenho muita vontade de brincar com cada uma desses modelos e frameworks, mas falta-me o tempo.
Codificarei o projeto supracitado em cada um dos modelos e frameworks, e publicarei um review para cada um deles aqui neste blog.
Também, quem quiser ver os códigos, eles estarão disponíveis no seguinte repositório:
https://github.com/frenetic/PHP-FrameWorks-Comparison

Participar?

Vamos analisar e discutir a partir da minha exeperiência de vida (afinal, é para isso que serve o diário de programador).

Na faculdade vi muitos grupos de estudo, células de aprendizado e organização de eventos acontecerem.
Não participei de nenhuma.
Não me arrependo por completo.
Porém, perto do fim do curso conheci a linguagem de programação Python pela qual me apaixonei, e movido por esse interesse descobri que na minha cidade/estado existia um grupo de estudo dessa linguagem, o PUG-PE (Python User Group – Pernambuco).
Desde que entrei faço questão de participar das discussões, tirar minhas dúvidas e ajudar a elucidar dúvidas de terceiros e, principalmente, ir para os encontros mensais!

É MUITO BOM PARTICIPAR!

Esse é um dos grandes motivos de participar de um grupo, é realmente muito bom!
Você pode aprender, conhecer gente nova, tomar umas cervejas e muito mais.
Gerar, distribuir e absorver conhecimento é muito prazeroso.
Quando você participa de algo, você tem a chance de conhecer melhor aquilo que se gosta, e tem uma excelente oportunidade de crescer como pessoa.
Também, participar ajuda no network, caso você queira trabalhar com a sua paixão!

Mas é para participar apenas de grupos de estudos?

NÃO!
Esse é apenas o exemplo que vivo atualmente, mas há muito outros lugares que você pode participar!
Projetos open source no GitHub, eventos de seu interesse, listas de discussão, forums de um jogo que você adora, clan de um MMORPG, e por ai vai!
O que importa é estar no meio de algo que você gosta, ser parte de um grupo e fazer com que o grupo cresça (não apenas em quantidade de pessoas, mas em conteúdo), que assim crescerás também!

Mas como achar um grupo? E se o grupo não existe?

Como achar um grupo?
Google é um bom começo.
Com certeza esse grupo pode estar em uma rede social, tal qual o Facebook ou Orkut.
E, com certeza, se este grupo existe, suas atividades, eventos e comentários pertinentes são divulgados no Twitter!
Basta dar uma procurada!

Se não conseguir encontrar o grupo nessas redes sociais e nem no Google, é porque o danado não existe.
A partir deste ponto, há duas soluções: desistir ou criar um grupo.
Criar um grupo pode dar trabalho, mas é um esforço recompensado.
Crie um centro de discussão, como o Google Groups ou algum forum, crie um perfil social e/ou um blog, convide seus amigos e comece a promover conteúdo e encontro!
Envolva todo mundo que goste do que você gosta.
Com certeza outros entusiastas irão aparecer para participar dos debates e eventos.

Dúvida?
Há um vídeo no YouTube que mostra a evolução do PUG-PE, contando a quantidade de participantes desde 2007 até 2011.
O conteúdo é bom, as pessoas são legais, os eventos são excelentes!
Ingredientes que fazem novos apaixonados em Python se agregarem cada vez mais ao PUG-PE.

Este artigo foi escrito no site CDVagabundo e pode ser lido na URL:
http://www.cdvagabundo.com.br/diariodeumprogramador/diario-de-um-programador-18-participe

Trabalho, atualmente, no escritório administrativo de uma empresa que ainda não está funcionando.
A construção da fábrica dessa empresa está perto do fim e o maquinário para começar a produção está chegando. A previsão é que no segundo semestre de 2011 possamos estar funcionando com força total.
Aqui sou líder de uma grande EUquipe de programação.
Para este cargo ganho X Reais.

Alguns colegas daqui da empresa e um pessoal da faculdade me perguntam por que eu não troco de emprego.
Por que que eu não vou para uma empresa que me pague melhor e que eu tenha oportunidade de crescer profissionalmente?

É, vale salientar que dentro da empresa que estou é praticamente impossível subir profissionalmente.

Já fui convidado algumas vezes para sair daqui.
Para ir para outras empresas para fazer o mesmo, até mesmo trabalhar menos, e ganhar cerca de duas a três vezes mais como salário inicial, podendo crescer dentro da empresa.
Não fui.
Sempre digo não para essas oprotunidades.

Ai você se pergunta, Mas por que FReNeTiC?

O investimento feito na empresa que estou atualmente já passou dos R$4.000.000.000,00 (Quatro bilhões de Reais).
É ou não é uma boa empresa para se ter no currículo?
Além disso, semana passada estive do lado de 1 roteador Cisco que vale, montado, quase R$5.000.000,00 (Cinco milhões de Reais).
Também, aqui acabaram de ser montados dois blade server da HP, que devem valer juntos, e montadinhos, uns R$4.000.000, 00 (Quatro milhões de Reais).

Já viram isso funcionando?
Tem som de TeraBytes!

Além disso, aqui estou tendo a oportunidade de estar a frente das especificações e análises técnicas de uma licitação, além de ver muita coisa interessante acontecer aqui quando o assunto é TI.

Vale a pena?

Essa é a questão, vale a pena estar aqui ou invés de ir atrás de melhores salários?

Para mim vale.
Sou novo, ainda moro com a minha mãe, não tenho filhos e nem despesas expressivas.
Pondero muito sobre isso e, por enquanto, ainda vale a pena estar onde estou e ver muita coisa acontecer.
O que vejo e aprendo aqui na empresa mata muito a minha curiosidade nerd de descobrir como funciona uma super empresa, como é o TI, o planejamento, os equipamentos.
Não conheço ninguém que tem uma oportunidade parecida com a minha.

Claro que, uma hora essa oportunidade já não terá tanto peso, e ai não irá mais valer a pena.
Num futuro MUITO próximo, quero atingir objetivos maiores, ganhar mais, ter um cargo bem mais expressivo e colocar toda a minha experiência e aprendizado em prática.

Acredito que essa possa ser a dúvida de muita gente, começar logo uma carreira estável ou aprender muito?

Aqui, vale reflexão.
Eu sou muito curioso e gosto muito de aprender e ver as coisas funcionando.
Pra mim, vale muito a pena a experiência que estou tendo.

Por outro lado, conheço gente que é louca para atingir logo um cargo grande em uma empresa e ter um super salário logo quando formado.
Ou então montar a sua empresa e lutar para que ela vire uma grande empresa.
Isso também é experiência e aprendizado. Os caminhos, o esforço e o estudo que você precisa para alcançar seus objetivos, o que muitas vezes vai ser solitário e tomando muita porrada da vida, tudo isso, é bem interessante.

Essa decisão é “de momento” e “de gosto”.
Vale a pena experimentar um pouco de cada.
Afinal, ter conhecimento, experiência e fazendo o que você é apaixonado, não é palpável a qualquer um.

Este artigo foi escrito no site CDVagabundo e pode ser lido na URL:
http://www.cdvagabundo.com.br/diariodeumprogramador/diario-de-um-programador-17-um-bom-salario-vs-uma-boa-oportunidade

Como bom programador que sou fui correndo descobrir como que funcionava essa mistura PHP + GTk, e aproveitei a necessidade de um tio meu que é psiquiatra que precisava manter anotações dos seus pacientes como comportamento e remédios que haviam sido receitados.
Surgiu então o ConSys Beta, um pequeno projeto pessoal que fiz para aprender como utilizar PHP + GTk.
Aproveitei a experiência para aprender a modelar interfaces GTk com o aplicativo Glade, o que se tornou um aprendizado bastante útil.

O projeto ConSys Beta está com seu código todo comentado para facilitar o aprendizado de quem desejar aprender um pouco de PHP + GTk.
O projeto pode ser baixado pela URL www.frenetic.com.br/projetos/conSys/ConSys.zip e tem cerca de 18Mb comprimido em um arquivo Zip.

Screenshots do projeto:

Tela inicial do projeto

tela inicial - filtro de busca

tela inserir e editar usuario

tela de verificação das consultas do paciente

tela de inserção e edição de consulta

E como é possível não virar escravo?

NÃO SEI!
A tecnologia vicia!

É fácil ver o pessoal da computação, ou a famosa turma da TI, virar noites e mais noites acordados na frente do computador ou deixar a vida social de lado para estar mechendo em algum gadget.
Fazemos isso por que amamos a tecnologia, e por que é o mal da profissão (ossos do ofício).

As vezes, quando em um projeto é muito desafiador, interessante ou inovador, acabamos por misturar obrigação e prazer, trabalho e diversão.
É difícil, então, abrir mão de estar pesquisando, programando, mechendo e futucando, para estar fazendo algo tão “banal” quanto viver!
Somos atacados pela PEITICA!

Mas falando sério, é difícil não ser escravizado pela tecnologia e por toda a revolução e benefícios que elas nos trazem, mesmo que ninguém perceba.
É fácil ver nerds em suas horas livres, depois de muito estudo e trabalho, falando sobre tecnologia e todas as suas fofocas, sobre as empresas que lançam produtos, sobre gadgets e sobre revoluções feitas no core do Linux.
Esse tipo conversa é pura escravidão tecnológica!

Tá bom, e qual o problema nisso?

Qual o escravo da tecnologia que não dorme de madrugada e não acorda cedo?
Que muda seus hábitos alimentares para poder conseguir comer com uma única mão na frente do computador?

Pode não parecer, mas estamos nos matando aos poucos…
O pouco sono afeta a memória e o coração, a alimentação vai tudo para a barriga e faz celulite na bunda, e viver NA tecnologia destrói aos poucos a nossa habilidade de se socializar.
De fato, conseguimos manter amizade com os outros viciados em tecnologia como nós…

Não sei vocês, mas estou tentando me policiar, afinal passo no mínimo 14 horas diárias na frente do computador, e já ganhei 2.5 graus no meu óculos, que antes eu não usava, além de uns 17 quilinhos.
Estou tentando conquistar a minha alforria, mas só de pensar que o CDVagabundo precisa ser atualizado já começo a me preocupar se há alguma lei Áurea para a minha tecnoescravidão…

Este artigo foi escrito no site CDVagabundo e pode ser lido na URL:
Diário de um Programador 16: escravo da tecnologia

No nosso exemplo iremos pegar esta imagem:

E transformar em mais ou menos isso:

Para tanto iremos precisar da linguagem PHP (como diz o título do artigo, duh!) e da biblioteca GD ativada nas configurações da linguagem, o que é bastante comum nos servidores e instalações desktop (vide xampp).

O código que faz a conversão é o seguinte:

<?php

/*    abrimos a imagem    */
$arquivo = imagecreatefromjpeg("epic.jpg");

/*    verificamos se estamos com o stream aberto    */
if ( $arquivo ) {

    /*    pegamos a largura e a altura da imagem para ser utilizado no loop de leitura    */
    $largura = imagesx( $arquivo );
    $altura = imagesy( $arquivo );

    /*    damos um loop de linha em linha    */
    for ( $y = 0; $y < $altura; $y = $y + 1 ) {

        /*    damos o loop para ir de colona em coluna    */
        for( $x = 0; $x < $largura; $x = $x + 1 ) {

            /*    pegamos a cor alocada na posição (x, y) da iamgem    */
            $rgb = @imagecolorat($arquivo, $x, $y);
            $cores = imagecolorsforindex($arquivo, $rgb);

            /*    imprimimos um * com a cor do ponto    */
            echo "<font style='color:rgb("
                . $cores["red"] . ","
                . $cores["green"] . ","
                . $cores["blue"] . ")'>*</font>";

        }

        /*    chegamos ao fim do loop das colunas, então iremos imprimir a próxima linha    */
        echo "<br>";
    }
}
?>

Alguns podem não estar familiarizados com as funções:

• ImageColorAt – Que le o ponto (x, y) da imagem e retorna um inteiro contento as cores R,G,B daquele pontoImageColorsForIndex – Que recebe o valor gerado por ImageColorAt e o divide em um array, o que facilita o nosso trabalho

Como podemos melhorar o nosso código?

Notem que o nosso loop lê a imagem ponto-a-ponto. Isso é legal pois deixa o nosso resultado bastante nítido, mas a ponto de desempenho é absolutamente pífio.
Podemos dar uma melhorada no desempenho da nossa conversão reduzindo a quantidade de pontos retirados da imagem, mas tentando evitar a perda de nitidez.

Ao invez de pegar ponto-a-ponto na imagem podemos pegar 1 ponto a cada 3 pontos fazendo a seguinte alteração:

alterar a linha 17 que contém:

for( $x = 0; $x < $largura; $x = $x + 1 ) {

para:

for( $x = 0; $x < $largura; $x = $x + 3 ) {

Note que o desempenho atual foi bem maior e que a sua imagem pode ter ficado um pouco distorcida.
Para melhorar o problema da distorção, faça a mesma alteração no loop das linhas, alterando a linha 14 que contém:

for ( $y = 0; $y < $altura; $y = $y + 1 ) {

para:

for ( $y = 0; $y < $altura; $y = $y + 3 ) {

Claro que este código pode ser melhorado mil vezes, tanto em desempenho quanto em funcionalidade.
Ele pode ser alterado para abranger outros formatos de imagem usando funções como ImageCreateFromGif, ImageCreateFromPng, etc.

Este artigo foi escrito no site PapoGeek e pode ser lido na URL:
http://www.papogeek.com.br/2010/07/transformando-imagens-em-arte-ascii-com-php

A implementação foi feita usando a linguagem de programação Python, a biblioteca Python para manipulação de imagens PIL e a biblioteca de interface gráfica padrão Tkinter.

A aplicação recebe como dados de entrada:

• k = A quantidade de números que irão compor cada vetor;
• w = A quantidade de vetores de peso (W);
• nAC = A quantidade de iterações de aprendizagem;
• Fator de aprendizagem inicial;
• Fator de aprendizagem final;
• Um arquivo contendo os números que serão utilizados pelo algoritmo;

A aplicação gera/retorna:

• Retorna os vetores de peso inicial;
• Retorna os vetores de peso após as iterações de aprendizagem;
• Retorna a quantidade de operações utilizadas no processo de aprendizagem;
• Gera um arquivo chamado VetoresDeTreino.jpg que exibe todos os vetores de treino;
• Gera um arquivo chamado VetoresDePesoAntes.jpg que exibe todos os vetores de peso antes do aprendizado;
• Gera um arquivo chamado VetoresDePesoDepois.jpg que exibe todos os vetores de peso depois do aprendizado;

Note que as 3 imagens só serão geradas se a quantidade de números (k) que irão compor cada vetor for igual a 2 (duas dimensões).

O projeto pode ser baixado no link Algoritmo competitivo em Python ou através da URL:
www.frenetic.com.br/projetos/ia_python/IA_Python.zip

Screenshots do projeto:

Janela Principal

VetoresDeTreino.jpg

vetorPesoAntes.jpg

vetorPesoDepois.jpg

Divirtam-se!