Archive for Artigos e Textos

Smarty Template Engine: Usar ou não?

November 14, 2011 FReNeTiC No comments

Antes de responder a pergunta feita no título desse post primeiro precisamos entender o que é template engine, o que é Smarty e por que usar uma template engine?.

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?

Artigos e Textos, PHP, Smarty, Tutoriais de desenvolvimento , , , ,

[Comparando Frameworks PHP] Parte 02: Banco de Dados do Projeto

September 19, 2011 FReNeTiC No comments

Antes de começar a desenvolver a aplicação, faz-se mister definir o banco de dados e as ações do usuário no sistema, assim como as ações de resposta do sistema.
Tendo isso definido, pode-se desenvolver sistemas parecidos, mesmo que utilizando frameworks e/ou linguagens diferentes.
Neste post vamos definir o schema (modelo) do banco de dados da nossa aplicação.
Posteriormente, em outro post, definiremos as ações e alguns wireframes da aplicaçã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!!!

Artigos e Textos, Comparando Frameworks PHP

[Comparando Frameworks PHP] Parte 01: Introdução

September 10, 2011 FReNeTiC No comments

PHP e eu:

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

Artigos e Textos, Comparando Frameworks PHP , , ,

Diário de Programador 18: Participe!

August 5, 2011 FReNeTiC No comments

Uma das dicas mais simples que posso dar para quem gosta do que faz e, em especial, ao pessoal da computação e afins: PARTICIPE!

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

Artigos e Textos, Diário de um Programador , , , ,

Diário de um Programador 17: Um bom salário VS uma boa oportunidade

February 24, 2011 FReNeTiC One comment

Após um bom tempo sem escrever um Diário de Programador, trago hoje um fato da minha vida que muitos me perguntam e eu sempre penso a respeito: O que vale mais, um bom salário ou uma boa oportunidade?
Claro que nesta dicotomia estou considerando que ambas as opções são para fazer algo que você realmente gosta.
Afinal, comentando o que todo mundo já sabe: “faça o que você gosta e o que te dá prazer, ou vire dona de casa”.

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

Artigos e Textos, Diário de um Programador , , ,
Página 1 de 41234