A melhor IDE para programar em PHP: Netbeans.

O NetBeans é um Ambiente de Desenvolvimento Integrado para múltiplas linguagens de programação, disponível em mais de 20 idiomas.
O foco inicial dos desenvolvedores do aplicativo era a linguagem Java — mas o ambiente já suporta plenamente o PHP, C, C++ etc. — e vem oferecendo recursos cada vez mais atraentes para programadores de outras linguagens.
Captura de tela do netbeans
O NetBeans é livre e de código aberto e começou a se tornar popular entre os desenvolvedores PHP, a partir de 2008.
Neste texto, vou procurar mostrar algumas razões para optar pelo desenvolvimento com esta ferramenta e, em seguida, como instalar a versão mais adequada para você.
Embora o foco de instalação do NetBeans, neste post, seja o Linux (Ubuntu, mais precisamente) — o procedimento para baixar e instalar é o mesmo para qualquer outro ambiente — seja outro sabor do Linux, MacOS ou Windows.

Por que usar o NetBeans para desenvolver suas aplicações?

O NetBeans é uma IDE — Integrated Development Environment. Em português, um Ambiente Integrado de Desenvolvimento.
Entre as principais características deste aplicativo, citam-se:

  • Criação e gestão de projetos — A IDE para PHP nos permite criar projetos, que poderão crescer. O NetBeans tem recursos relativos à gestão de projetos de softwares, que vão desde a facilidade para criar documentação à testar os programas criados.
  • Recursos de edição do código fonte — O editor vem equipado com uma coletânea de recursos voltados para projetos em PHP, realce da sintaxe para PHP (syntax highlighting) etc.
  • Suporte a gestão de bancos de dados — e de serviços web.
  • Detecção de erros — mostra erros de parsing em seu código PHP, entre outros.

Requisições de sistema para instalar o NetBeans

O NetBeans está disponível nas mais diversas plataformas.
Ainda que seja um software robusto, ele não requer um hardware “irracional” para ser usado.
Já experimentei o NetBeans em um netbook, com processador Intel 800 MHz, com 2 Gb de memória (a configuração de hardware mínima) RAM — ele demora um pouco pra carregar, mas é perfeitamente usável.
De forma resumida, você precisa de uma tela com resolução mínima de 1024×768 e suporte à máquina virtual Java (JVM).
Veja, a seguir, o hardware recomendado na documentação oficial.

Plataforma Hardware mínimo Hardware recomendado
Ubuntu 12.10 ou superior, OS X 10.8 Intel e Windows 7 Processador: 800MHz.
Memória: 512 MB.
Disco: 650 MB de espaço livre em disco.
Processador: Intel Core i5 ou AMD Athlon X4.
Memória: 2 GB (32-bit), 4 GB (64-bit).
Disco: 1.5 GB de espaço em disco livre.

Se você quiser mais detalhes sobre as requisições de sistema, veja os links no final do artigo.
Há outras distribuições Linux que funcionam perfeitamente com o NetBeans, tal como o Fedora (RedHat), OpenSuse etc.
O Ubuntu 12.04 tem suporte até 2017 — e é uma das opções mais estáveis.

Como baixar e instalar o NetBeans no Linux

O NetBeans se encontra disponível nos repositórios oficiais das grandes distribuições.
Se você usa Ubuntu ou alguma distro baseada nele, pode clicar no botão abaixo para iniciar a instalação a partir do Software Center.

Clique para baixar e instalar o aplicativo

Se preferir usar o terminal, use o comando abaixo para instalar a versão mais estável do NetBeans no Ubuntu:

sudo apt-get install netbeans

Usuários do Fedora, podem usar o yum:

yum install netbeans

Usar os repositórios oficiais para instalar o NetBeans, é sempre a melhor maneira de executar a tarefa — por que você não precisa se preocupar com as dependências, por exemplo.
O gerenciamento de pacotes da sua distribuição Linux entrega o NetBeans instalado e pronto para uso, em poucos minutos para você (dependendo da sua conexão).
Se você prefere uma versão mais atual, recomendo buscar os arquivos de instalação no site oficial de downloads do NetBeans.
No site de downloads, é possível optar por versões em Desenvolvimento ou nightly builds — que não devem ser usadas em ambiente de produção, por conterem recursos experimentais, que poderão estar presentes em futuras versões.
Escolha, no canto superior da página de downloads, o seu idioma preferido e o sistema operacional para o qual você deseja baixar o NetBeans.
A seguir, opte pela versão customizada para desenvolver em PHP.

captura de tela do site de download do netbeans
Clique, para ver detalhes.

Ao clicar em Download, você será levado a uma segunda página e o programa de instalação deverá começar a baixar automaticamente, em alguns segundos.

Como instalar o NetBeans

Uma vez baixado o programa de instalação (netbeans-X.X.X-php-linux.sh), ele precisará ter suas permissões alteradas para poder ser executado:

chmod aug+x netbeans-8.0.1-php-linux.sh

Em seguida, já é possível executá-lo:

./netbeans-8.0.1-php-linux.sh

Alguns problemas de instalação são previstos na documentação oficial — principalmente se você ainda não tiver instalado o JDK, ou seja o suporte Java.
Não havendo problemas, a instalação prossegue normalmente.
captura de tela de instalação do netbeans

É possível ter mais de uma versão do NetBeans instalada?

captura de tela da splash screen do netbeans
Múltiplas instalações ou versão do NetBeans podem coexistir no mesmo ambiente.
Um exemplo de utilidade desta situação é querer usar a versão mais estável pra sua distro Linux, para desenvolver seu código com segurança — e ter também uma versão em desenvolvimento (nightly build), para poder dar uma olhada nas novidades que estão sendo testadas para as próximas versões do produto.
Se quiser fazer o download da versão em desenvolvimento do NetBeans, clique aqui.
Além disto, o NetBeans torna fácil importar as configurações de usuário da versão antiga pra nova — e você não precisa desinstalar nada, antes de experimentar o novo.

LEIA MAIS

REFERÊNCIAS

Sistemas de arquivos otimizados para mídias flash, cartões de memória, SSD, NAND

Mídias em estado sólido têm problemas diferentes das tradicionais mídias magnéticas rígidas ou flexíveis, embora possuam interfaces similares.
Cartões de memória flash, pendrives, unidades SSD etc. requerem tratamento especial e possuem processos de detecção e correção de erros de gravação/leitura diferentes —, além de técnicas para prolongamento do tempo de vida útil (wear leveling).
pen-drive-sandisk
Tipicamente, dispositivos como as unidades SSD realizam estas operações internamente, o que permite que um sistema de arquivos comum possa ser usado nelas.

Os meios de armazenamento flash sofrem de duas grandes limitações em relação às mídias magnéticas tradicionais.
— Os bits só podem ser apagados, removendo um grande bloco da memória.
— Cada bit suporta passar por um número limitado de processos de remoção — após o que, já não pode mais armazenar dados de maneira confiável.
Em função destas limitações, são requeridas outras estruturas de dados e algoritmos para fazer uso efetivo destes meios de armazenagem.

Contudo, em alguns casos específicos, sistemas de arquivos otimizados para memória flash podem ser necessários ou recomendados.
Você provavelmente nunca ouvir falar da maioria dos sistemas, que seguem. Muitos deles foram projetados por empresas para serem usados internamente, em seus próprios dispositivos. Alguns deles sequer são acessíveis ao público.
Se você tem algum projeto em mente e pensa em qual sistema de arquivos seria o mais adequado, espero que este artigo te ajude a encontrar algumas respostas.

CASL

É um sistema de arquivos desenvolvido pela Nimble Storage, que usa os dispositivos SSD para fazer o tradicional cache dos discos rígidos usados nos produtos da empresa.

ETFS

Corresponde a Embedded Transactional File System projetado pela QNX Software Systems para ser usado em dispositivos NAND.

exFAT

Criado pela Microsoft, otimizado para drives flash e amplamente difundido. Como já era de se supor, é proprietário.
A sugestão de uso é nos dispositivos flash, onde o NTFS não for a solução mais razoável (como a sobrecarga na estrutura de dados), ou onde o limite do tamanho de arquivo seja incompatível com os padrões do FAT32.
Tem sido adotado pela SD Card Association como padrão para cartões SDXC maiores que 32 GiB.

ExtremeFFS

Sistema de arquivos interno para dispositos de estado sólido (SSD) — desenvolvido pela SanDisk, que permite uma melhora na performance de escrita aleatória na memória flash, se comparado aos sistemas tradicionais, como o TrueFFS (veja abaixo).
A SanDisk alega que a tecnologia incrementa a velocidade de acesso randômico em drives de estado sólido em 100 vezes.
A empresa planeja usar o ExtremeFFS nas próximas implementações de memória flash NAND, de células multinível.

F2FS

O Flash-Friendly File System é um sistema de arquivos de código aberto, introduzido pela Samsung em 2012.
A empresa desenvolveu o F2FS do zero, levando em conta as características dos dispositivos de armazenamento baseados em memória flash NAND — tais como unidades SSD, eMMC e cartões SD, que são largamente usados em sistemas computacionais, desde dispositivos móveis (smartphones) a grandes servidores.
A Samsung escolheu a abordagem estruturada por logs, para desenvolver o projeto do F2FS.
O projeto foi adaptado para atender a novas formas de armazenagem de dados e ajuda a remediar alguns problemas conhecidos entre outros sistemas de arquivos log-structured.
Leia mais sobre o F2FS, aqui.
O sistema resolve o efeito bola de neve causado por um problema chamado wandering tree, que causa sobrecarga durante o processo de limpeza.

Como usar o sistema de arquivos F2FS no Linux

Se quiser experimentar o sistema de arquivos em algum dispositivo de memória flash, que você tenha disponível, use o comando mkfs:

mkfs.f2fs /dev/sdb1
mount -t f2fs /dev/sdb1 /mnt/f2fs 

Não se esqueça de substituir /dev/sdb1 pelo nome endereço real do seu dispositivo.
Usuários do Ubuntu, precisam instalar o pacote de aplicativos F2FS-tools, para poder realizar o procedimento acima:

sudo apt-get install f2fs-tools

Enfim, a Samsung adicionou uma série de parâmetros para configurar o layout do dispositivo, selecionar alocações e melhorar os algoritmos de limpeza.

Como usar o sistema de arquivos F2FS no Android

A maneira mais fácil é baixar um aplicativo no Google Play que faça a conversão do atual sistema de arquivos para F2FS.

FFS2

Este sistema provavelmente substitui o FFS1, também da Microsoft, e é um dos primeiros desenvolvido pela empresa, para uso em mídias flash.

JFFS

Sistema de arquivos estruturado por log, para Linux, desenvolvido para uso em mídias flash NOR.
Substituído pelo JFFS2 (veja o próximo item).

JFFS2

Sucessor do JFFS, que inclui suporte a mídias flash NOR e NAND.
O Journaling Flash File System version 2 é um sistema de arquivos estruturado por log, projetado para uso em dispositivos flash em sistemas embutidos.
Se diferencia de outros sistemas de arquivos antigos por não usar uma camada de tradução nos dispositivos flash, para simular um disco rígido.
Ele põe o sistema de arquivos direto nos chips dos dispositivos flash.
O sistema foi desenvolvido pela Red Hat, baseado no trabalho anterioraa empresa sueca, Axis Communications, conhecida pelos seus produtos na área de vigilância.
Se você tem interesse em estudar e usar este sistema de arquivos no Linux, pode encontrar mais informações neste site.
No Ubuntu, você precisará instalar alguns pacotes para poder criar um sistema de arquivos JFFS2 em dispositivos flash. Use o comando apt-cache, para saber quais:

apt-cache search jffs2
logfs-tools - Tools to manage logfs filesystems
logfs-tools-dbg - Tools to manage logfs filesystems (debug)
mtd-utils - Memory Technology Device Utilities

Por sorte, as ferramentas logfs-tools são as mesmas a ser usadas pro próximo sistema de arquivos, descrito abaixo.

LogFS

O LogFS é um sistema de arquivos relativamente novo, também desenvolvido para Linux e que tem a intenção de, futuramente, substituir o JFFS2.
Uma de suas vantagens, em relação ao seu antecessor, é a melhor escalabilidade.
O LogFS é também um sistema de arquivos estruturado por logs (log-structured), concebido para mídias flash de grande capacidade.
O sistema foi desenvolvido inicialmente por Jörn Engel, em 2008, inspirado em outro sistema de arquivos do NetBSD e é suportado desde a versão 2.6.34 do kernel Linux (2010).

O que faz o LogFS se destacar: snapshots

Um dos destaques do LogFS é a possibilidade de tirar snapshots do sistema de arquivos — atualmente, nenhum sistema de arquivos tradicional para Linux faz isto.
Algumas pessoas chamam os snapshots de versões.
O recurso equivale a “tirar fotos” ou criar imagens de todo o sistema de arquivos em dados momentos.
Imagine a possibilidade de ter removido acidentalmente todo o seu diretório /home. Com este recurso, é possível voltar no tempo — analisar os diversos snapshots tirados e escolher para qual deles voltar.
É como se o acidente não tivesse acontecido.
Outra forma de ver o processo é como se o sistema de arquivos oferecesse vários backups de si mesmo, em vários momentos. Ele não consome muito espaço para fazer isto.
Se você usa o Ubuntu e deseja experimentar o LogFS, instale os pacotes relacionados a ele:

sudo apt-get update
sudo apt-get install logfs-tools

O tamanho do pacote não é monstruoso — pelo contrário, ocupou pouco mais de 64 Kb no meu sistema.
Uma vez instalado, para formatar um dispositivo com este sistema de arquivos, basta usar o comando mkfs.

NVFS

O nome Non-Volatile File System corresponde a, em português, “sistema de arquivos não volátil” e foi introduzido pela fabricante de dispositivos móveis Palm.
O último dispositivo a fazer uso deste sistema, feito pela Palm, foi o Treo 650.

OneFS

Este sistema foi desenvolvido pela Isolon para atender seus projetos de sistemas de armazenamento em clusters.
A Isolon foi adquirida pela EMC Corp, em 2010.
O sistema OneFS suporta alocação seletiva de metadados diretamente no dispositivo flash SSD.

RFS

O Robust File System é desenvolvido pela Samsung e usado em suas TV’s, no espaço reservado às aplicações dos usuários.
O RFS é baseado no sistema de arquivos da Microsoft FAT 16/32, com uma espécie de journaling incluído.
O seu código é proprietário e ele só é usado em equipamentos da Samsung, tais como smartTVs, reprodutores BluRay e alguns celulares.
O site SamyGo tem um tutorial (em inglês) que descreve como usar este sistema para:

  • alterar o firmware da sua TV
  • e criar novos kernels para a sua TV ou outros dispositivos Samsung.

Segger Microcontroller Systems emFile

Este sistema de arquivos é usado em aplicações “profundamente” embutidas, com suporte a mídias flash NAND e NOR.
Tem recursos de wear leveling, escrita e leitura rápida e consumo muito baixo de memória RAM.

SafeFLASH

Sistema de arquivos HCC-embedded, seguro contra falhas, que provê suporte a mídias flash NAND e NOR, com integração a wear-leveling e manipulação de blocos defeituosos (bad blocks).

TFAT

Uma versão transacional do sistema de arquivos FAT.

TrueFFS

Apesar do nome, o TrueFFS não é exatamente um sistema de arquivos — ele não provê uma interface de sistema de arquivos, mas uma interface de disco.
O termo mais correto é camada de tradução flash — flash translation layer.
O sistema foi projetado para rodar em drives de estado sólido raw —. Atualmente, a maioria dos SSDs vendidos ao consumidor não são deste tipo.
O projeto implementa correção de erros, remapeamento de blocos defeituosos e wear leveling.
A função de uma camada de tradução flash é adaptar um sistema de arquivos pleno às limitações e restrições impostas pelos dispositivos de memória flash.

UBIFS

Este sistema de arquivos pretende suceder o JFFS2 e concorre com o LogFS, otimizado para uso de memória DRAM não volátil.
O nome quer dizer Unsorted Block Image File System.
Seu desenvolvimento iniciou-se em 2008 e ele já integra o kernel do Linux, desde a versao 2.6.27.
O sistema está sob desenvolvimento dos engenheiros da Nokia, com a ajuda da Universidade de Szeged, na Hungria.

UFFS

O Ultra low cost flash — ou sistema de arquivos de ultra baixo custo para sistemas embutidos foi concebido, de acordo com a página oficial, para as seguintes situações:

  • quando os recursos de hardware são muito limitados (capacidade de memória RAM entre 64 Kb e 512 Kb) mas, ainda assim, você precisa de um sistema de arquivos confiável para dispositivos de armazenamento flash
  • quando o JFFS/JFFS2 são lentos e consomem muita memoria
  • quando o YAFFS/YAFFS2 se encaixa perfeitamente, mas consome muita memória
  • quando você precisa que o projeto seja livre e de código aberto

O UFFS2, segundo os desenvolvedores, terá as seguintes melhorias:

  1. menor fome de memória, com a redução de 25-50% da necessidade atual;
  2. possibilidade de abrigar um ou mais arquivos/diretórios em um único bloco, o que melhora significativamente o uso do espaço, para arquivos pequenos;
  3. suporte a links simbólicos e outros arquivos especiais;
  4. wear-leveling estático e
  5. suporte a mais chips flash NAND.

Unison RTOS

Este sistema de arquivos é voltado a sistemas embutidos com mídias flash de baixo custo NAND ou NOR.
O Unison RTOS oferece um sistema de arquivos para Linux 32 bits compatível com o POSIX.
O sistema de arquivos é muito leve e pode ocupar um espaço muito pequeno (1 Kb, em algumas arquiteturas).
É de código aberto e segue padrões abertos — e isto sempre conta pontos a favor.

WAFL

O WAFL – Write Anywhere File Layout – é um sistema de arquivos interno utilizado pela NetApp em seus dispositivos DataONTAP OS, originalmente otimizado para uso de memória DRAM não volátil.

XCFiles

Trata-se de uma implementação exFAT, pela DataLight para sistemas operacionais embarcados Wind River VxWorks.

YAFFS

Um sistema de arquivos estruturado por logs, projetado para mídias flash NAND — mas também adequado a flash NOR.
O nome dele é um acrônimo para mais um sistema de arquivos flash — ou Yet Another Flash File System.
O projeto foi inicialmente desenvolvido por Charles Manning
O sistema de arquivos é disponibilizado pela licença GPLv2 e pode ser embarcado em vários sistemas operacionais, como:

  • Android
  • Firefox OS
  • Linux
  • Windows CE, pSOS, eCos, ThreadX etc.

O YAFFS é robusto e mantém a integridade dos dados como prioridade.
O objetivo secundário do YAFFS é a alta performance.
Em situações onde não há um sistema operacional, é possível usar uma variante: YAFFS/Direct — que tem o mesmo sistema de arquivos central, contudo com um interfaceamento simplificado.

ZFS

Um sistema de arquivos combinado e gerenciador de volumes lógico, projetado pela Sun Microsystems.
Os recursos do ZFS inclui proteção contra corrupção de dados, suporte a altas capacidades de armazenamento, compressão de dados eficiente, integração dos conceitos de sistema de arquivos e gestão de volumes, snapshots e clones de cópia-na-escrita.
A lista de recursos segue com verificação de integridade contínua e reparo automático, RAID-Z e NFSv4 ACLs nativos.
O projetos começou como software de código aberto e seguiu com a licença CDDL — Common Development and Distribution License.
Leia mais sobre esta tecnologia em Introdução ao sistema de arquivos ZFS.
O nome ZFS é marca registrada da Oracle Corporation.

OTFS

Segundo a InformationWeek, o OmniTraak File System é um sistema de arquivos extensível do “estado da arte”.
O OTFS é um componente de software que organiza o conteúdo do disco em arquivos, provê controle de acesso e segurança e oferece métodos de nomenclatura de arquivos.

Referências

Além dos vários links espalhados pelo texto, você pode também conferir as seguintes páginas na Wikipedia:
http://en.wikipedia.org/wiki/List_of_file_systems#File_systems_optimized_for_flash_memory.2C_solid_state_media
http://en.wikipedia.org/wiki/Flash_file_system

Apache: Como resolver o erro “Could not reliably determine the server’s fully qualified domain name, using 127.0.1.1 for ServerName”

A mensagem obtida não é exatamente um erro. Trata-se de um aviso (amigável) de que algo não está funcionando do modo esperado — o que não impede o Apache de rodar e executar todas as suas funções.
Se a mensagem está te incomodando, contudo, veja abaixo como é fácil resolver.
apache logo software foundation

Encontre o arquivo de configuração do Apache

O arquivo de configuração do Apache (dependendo da versão que você estiver usando), é um destes dois:

  • /etc/apache2/httpd.conf
  • /etc/apache2/apache2 — no Debian, no Ubuntu e nas outras distros baseadas nelas
  • /etc/httpd/conf/httpd.conf — no Fedora Core, CentOS, Red Hat etc.
  • /usr/local/etc/apache22/httpd.conf — no FreeBSD 6.1 (com Apache 2.2)
  • /etc/httpd/httpd.conf — no Slackware 14.0
  • /etc/apache2/httpd.conf — no OpenSUSE (Apache 2.2)

Encontre o seu.

O Debian (e o Ubuntu, por consequência) guarda os arquivos de configuração do Apache 2.0 no diretório /etc/apache2.
Normalmente, o principal arquivo de configuração do Apache se chama httpd.conf — embora este arquivo até se encontre no Debian, sua função é apenas manter a compatibilidade com outros softwares que esperam encontrá-lo lá.

Você pode encontrar mais informações sobre a localização dos arquivos do Apache no site Wiki oficial.
No Ubuntu 14.04, o arquivo de configuração do Apache, é o segundo da lista, acima. Vou basear os exemplos, que seguem, nesta configuração.
Quem usa outra distro Linux (ou outro sistema operacional) só precisa ajustar o exemplo ao seu caso.

Ajustando o arquivo de configuração do Apache

Antes de sair mexendo “nas coisas”, vamos fazer backup do arquivo:

sudo cp /etc/apache2/apache2.conf /etc/apache2/backup.apache2.conf

Em seguida, abra o arquivo de configuração e acrescente (pode ser no final):

ServerName	localhost

Feito isto, reinicie o Apache:

sudo apache2 restart

NO Debian (e no Ubuntu), o comando para reiniciar o Apache é este:

sudo /etc/init.d/apache2 restart

Espero que isto tenha dado um fim à mensagem que estava te incomodando.

Leia mais

  • Sobre o LAMP — leia outros artigos sobre a configuração de um servidor Linux, Apache, MySQL e PHP.
  • Sobre o PHP — leia outros artigos sobre a linguagem de programação PHP.
  • Sobre o MySQL — leia outros artigos sobre o banco de dados MySQL.
  • Documentação oficial — onde você vai encontrar tudo o que precisa sobre o Apache.

PHP, MVC e hello world!

Neste post, vamos abordar a implementação da arquitetura MVC, com um exemplo prático, em PHP do clássico programa Hello World, para iniciantes.
Em artigo anterior, expliquei os conceitos básicos da arquitetura de projetos de software MVC (MODEL — VIEW — CONTROLLER). Agora, o objetivo é mesclar a teoria com a prática.

O que é a arquitetura MVC?

Embora possamos traduzir “model, view, controller” para “modelo, visão, controlador”, vou optar, neste post por mantê-los na forma original, para enriquecer um pouco o vocabulário do artigo.
A implementação original do MVC, na linguagem Smalltalk-80, com algumas variações, contém conceitos que se descrevem assim:

MODEL

Na sua forma mais simples, o MODEL armazena dados que serão acessados pelo VIEW e escritos pelo CONTROLLER.
É a parte mais complexa do sistema e contém toda a lógica específica da aplicação e é onde as entidades de domínio (domain entities), relativas aos conceitos do mundo real são armazenadas — tais como “um usuário” ou “uma ordem”).
É a parte da aplicação que recebe dados e os processa.
Além disto, lida com todos os acessos e armazenamento de dados — e não tem conhecimento dos CONTROLLERS ou VIEWS que fazem uso dele (o MODEL).

MODELS são aqueles componentes do sistema que realmente fazem o trabalho.

Por exemplo, no PHP, o MODEL pode representar um “usuário”, no sistema.
Ele pode tomar conta de todas as operações relacionadas aos usuários — gravando registros, recuperando-os, validando-os etc.
O que o MODEL NÃO É:

  • um simples ponto de acesso a dados;
  • uma classe chamada “model” que representa uma tabela dentro do banco de dados.

O VIEW

O view contém toda a lógica do display.
No PHP, esta é a parte da aplicação que gera o HTML.
Tem acesso direto ao MODEL e pode inquiri-lo para obter seus dados.
O VIEW pode criar callbacks para seu CONTROLLER — como um botão que, ao ser clicado, inicia uma ação).
No MVC, o VIEW interpela o MODEL para obter dados, diretamente.
Para evitar erros de interpretação, o VIEW NÃO É:

  • ausente de lógica;
  • receptor de dados do CONTROLLER.

O QUE É CALLBACK

Literalmente, callback quer dizer “chame de volta”.
Em computação, é uma porção de código executável, passado como parâmetro a outra porção de código.
Quando apropriado, a callback pode ser invocada e executada.

O CONTROLLER

O CONTROLLER recebe as entradas do usuário e atualiza o MODEL onde requerido.
Quando não houver interação humana direta, não há necessidade do CONTROLLER.
Em função disto, é importante que se diga, que não se trata de um mediador ou passagem entre qualquer uma das duas outras entidades.
O CONTROLLER acessa o MODEL, mas não contém qualquer lógica de display — tudo o que ele faz é responder às entradas do usuário.

CONTROLLERS são usados para enviar mensagens ao MODEL e prover uma interface entre este e os VIEWS associados a ele (p. ex., teclado, mouse etc.)
Cada VIEW deve ser pensado como sendo associado a um CONTROLLER cada qual com seu próprio MODEL. Mas este último, podendo ter muitos pares de VIEW/CONTROLLER.

Cada CONTROLLER está ligado a uma única instância de um VIEW e a uma única instância de um MODEL.
Coisas que o CONTROLLER NÃO É:

  • encarregado de instanciar o MODEL ou o VIEW — ele os enxerga, mas a flexibilidade é reduzida nas implementações que o forçam a selecionar qual VIEW ou MODEL está sendo usado;
  • uma passagem ou mediador entre o MODEL e o VIEW;
  • local onde os VIEWS são inicializados com base no estado de um MODEL. O CONTROLLER está ligado a uma única classe VIEW (embora possa ser atribuído a múltiplas instâncias) e responde a ações relacionadas.
    Uma lista de produtos constituiria uma única VIEW.

O fluxo do programa

O fluxo típico de um programa sob os padrões MVC, segue estes passos:

  • Inicialização do MODEL, do VIEW e do CONTROLLER.
  • O VIEW obtém dados do MODEL e é exibido ao usuário.
  • O usuário interage com o VIEW (clicando em algo, por exemplo), o que dispara uma ação do CONTROLLER.
  • O CONTROLLER atualiza o MODEL, de alguma forma.
  • O VIEW é renovado para exibir os dados atualizados do MODEL.

Hello World!

Já vimos um bom tanto de teoria.
Faz sentido ver como tudo isto se aplica à “vida real”, em uma pequena aplicação PHP.
Me acompanhe!

class Model {
     public $text;
     public function __construct() {
         $this->text = 'Hello world!';
     }        
} 

class View 
     private $model;
     private $controller;

     public function __construct(Controller $controller, Model $model) {
         $this->controller = $controller;
         $this->model = $model;
     }

     public function output() {
         return '<h1>' . $this->model->text .'</h1>';
     }
}
class Controller {
     private $model;

     public function __construct(Model $model) {
         $this->model = $model;
     }
}
// aqui inicia a triade
$model = new Model();
// eh importante que o CONTROLLER e o VIEW compartilhem o MODEL
$controller = new Controller($model);
$view = new View($controller, $model);
echo $view->output();

Os aplicativos “hello world!” não costumam ter interação com o usuário — pelo menos, este aqui, não tem.
Portanto, como ele só exibe dados, o CONTROLLER não faz nada aqui.

Interação do usuário

Se você ficou frustrado pelo fato de o CONTROLLER não ter sido relevante no exemplo anterior, vamos usar outra abordagem que preveja este tipo de interação.
Interação com o usuário é o primeiro problema da arquitetura MVC, na web — não há como criar uma callback pro CONTROLLER diretamente.
Além disto, toda a página tem que ser recarregada — o que ainda não é um grande problema, mas precisamos adicionar código que direcione a ação de volta ao CONTROLLER certo.
No nosso próximo exemplo, vamos adicionar ao código anterior algumas linhas que fazem com que a string “Hello world” seja seja substituída por “Texto Atualizado”, quando clicada.
Primeiro adicione um link pro VIEW. Você pode fazer isto adicionando uma callback ao CONTROLLER a partir do VIEW.
Em aplicações GUI, o CONTROLLER poderia ser apenas outro objeto na memória e a callback poderia ser uma simples chamada de função.
Na web, isto não é uma opção — uma requisição HTTP é a única maneira de acessar o CONTROLLER.

class View {
     private $model;
     private $controller;
     public function __construct(Controller $controller, Model $model) {
         $this->controller = $controller;
         $this->model = $model;
     }
     public function output() {
         return '<a href="mvc.php?action=textclicked">' . $this->model->text . '</a>';
     }
}

Na segunda requisição (callback), todos os componentes precisam ser reinicializados. Algum código precisa ser adicionado para direcionar a ação de volta ao CONTROLLER. Veja como:

$model = new Model();
//Eh importante que o CONTROLLER e o VIEW compartilhem o MODEL
$controller = new Controller($model);
$view = new View($controller, $model);
if (isset($_GET['action'])) $controller->{$_GET['action']}();
echo $view->output(); 

Tudo o que este código faz é chamar a ação do CONTROLLER — especificada por $_GET['action'], baseado na interação do usuário.
Enfim, uma ação do CONTROLLER, que lide com o evento, precisa ser adicionada ao código:

class Controller {
     private $model;
     public function __construct(Model $model) {
         $this->model = $model;
     }
     public function textClicked() {
         $this->model->text = 'Texto Atualizado';
     } 
}

Agora, quando a página for visitada, ela vai dizer “Hello World” e, quando o link for clicado, o texto muda para “Texto Atualizado”.
Pegue o código completo abaixo:

<?php
class Model {
	public $text;
	
	public function __construct() {
		$this->text = 'Hello world!';
	}		
}

class View {
	private $model;
	private $controller;
	
	public function __construct(Controller $controller, Model $model) {
		$this->controller = $controller;
		$this->model = $model;
	}
	
	public function output() {
		return '<a href="mvc.php?action=textclicked">' . $this->model->text . '</a>';
	}
	
}

class Controller {
	private $model;

	public function __construct(Model $model) {
		$this->model = $model;
	}

	public function textClicked() {
		$this->model->text = 'Texto Atualizado';
	}
}


$model = new Model();
//It is important that the controller and the view share the model
$controller = new Controller($model);
$view = new View($controller, $model);
if (isset($_GET['action'])) $controller->{$_GET['action']}();
echo $view->output();
?>

Leia mais sobre o assunto

Outros textos sobre a arquitetura MVC, neste site.
Outros textos sobre programação PHP, neste site.

http://www.siliconinfo.com/open-source-web-application/mvc-development.html

https://coderwall.com/p/l-a79g
https://r.je/mvc-in-php.html
Wikipedia
Leia mais sobre as definições usadas neste texto:
http://pt.wikipedia.org/wiki/Callback

Os princípios do MVC para desenvolvedores PHP

Os conceitos por trás do MVC, remontam à década de 60 e influenciaram linguagens de programação orientadas a objetos, como o Smalltalk-80 e incontáveis projetos, como o Apple Macintosh.
Sigla para Model-View-Controller ou Modelo-Visão-Controlador, o MVC pode ser definido como uma arquitetura de software ou padrão de projetos (design patterns).
diagrama da arquitetura MVC
Se isto fizer alguém se sentir mais seguro e confiante, não estamos falando de conceitos que “surgiram ontem” aqui.
Quando me pediram para escrever sobre o MVC (Model-View-Controller), tal como Marc Plotz, tive a percepção de que há muito pouco escrito sobre o assunto, que se possa chamar de relevante (eu sei, isto é apenas uma opinião) — alguns termos carecem de uma definição mais aprofundada.
Mas, quem deseja se aprofundar mais sobre um determinado assunto, deve procurá-lo em livros, enquanto meios mais adequados e confortáveis para se explorar conceitos.
Neste artigo, vou procurar expor o que sei sobre MVC, da maneira mais simples possível e sob a ótica de um programador PHP – onde reside boa parte da minha experiência enquanto desenvolvedor.

Vantagens do MVC

Para ser objetivo:

  • robusto;
  • escalável;
  • enxuto e muito bem escrito.

Quando eu era adolescente, meu pai, doutor em matemática, me deu alguns conselhos sobre como programar melhor. Um deles dizia “seu código não deve ultrapassar o tamanho de uma tela”.
Pode parecer bobagem, mas seguindo este princípio, nos anos 90, antes de ter qualquer formação acadêmica, eu já aplicava alguns dos conceitos da boa programação de que vamos falar aqui.
Ao seguir este princípio, sou obrigado a pensar o meu código para ser enxuto e livre de redundâncias.

O que é o MVC

A arquitetura de software MODEL – VIEW – CONTROLLER, usada na engenharia de softwares tem como princípio fundamental a idéia de que a lógica de uma aplicação deve estar separada de sua apresentação — ou seja, o MVC é uma maneira melhor de separar a lógica de construção da sua aplicação do modo como ela é vista.
Sua fundamentação é separar a aplicação em 3 partes principais, conhecidas como o Modelo, a Visão e o Controlador.
Observe o diagrama:

  • As linhas contínuas representam as associações diretas
  • As linhas tracejadas representam as associações inferidas

Estas últimas, são associações visíveis pelo ponto de vista do usuário, mas que não representam necessariamente a realidade do projeto de software.

Design patterns - MVC - padrões de projeto de software
Clique, para ampliar.

Uma das formas de pensar o MVC é considerar as seguintes situações:

  • Um usuário interage com o view, clicando em um link ou enviando dados em um formulário.
  • O Controller manipula os dados fornecidos pelo usuário e os transfere ao Model.
  • O Model recebe a informação e atualiza seu estado — o que significa realizar um cálculo envolvendo os dados fornecidos, adicioná-los a um banco de dados, pra citar alguns exemplos.
  • O View verifica o estado do Model e responde — listando os dados, fornecendo o resultado de um cálculo etc.
  • O View aguarda uma nova interação vinda do usuário.

Em termos práticos, o MVC representa uma boa filosofia de projetos.
A ideia de separar a ĺógica do display não é nova — mas o MVC consegue apresentá-la de uma forma mais amigável.
A apresentação e o layout são mais simples — e, como consequência, seu aplicativo pode ter uma manutenção mais fácil.
O View fica entre os arquivos de view, a lógica dentro do modelo (template) e o Controller manipula tudo.

A lógica de negócios

O termo, em inglês, é Business Logic.
O conceito é simples: lógica de negócios é o processo de calcular os processos lógicos de uma aplicação.
Exemplo: no caso de um calendário, a lógica de negócios consistiria em calcular a data atual, em que dia da semana estamos, quantos dias já se passaram desde o início do ano ou do mês etc.
Não se deixe confundir por termos bonitinhos — em uma aplicação a lógica de negócios se refere ao processamento das informações — simplesmente.

São rotinas que realizam entradas de dados, consultas aos dados, geração de relatórios e mais especificamente todo o processamento que se realiza por trás da aplicação visível para o utilizador (Backoffice). (Wikipedia)

Modelos

O termo, em inglês (para facilitar sua busca, caso deseje pesquisar mais sobre o assunto) é templates.
É comum frameworks MVC usarem algum tipo de sistema de modelos, para enfatizar o princípio DRY (veja abaixo), tornando mais fácil reusar código já pronto.
Há frameworks que rodam sobre o Smarty ou seus próprios mecanismos de modelos – ou nenhum.
Especialistas avisam que alguns mecanismos de modelos (template engines) possuem sintaxe um tanto complicada — o trabalho de aprendizagem pode não valer a pena. Se informe antes de começar a aprender uma nova linguagem, que pode servir apenas para renderizar páginas.

DRY

A palavra dry, em inglês, que dizer “seco” ou “enxuto” — isto pode ajudar a memorizar.
No contexto de que estamos tratando, tem outro significado: Don’t Repeat Yourself — ou seja, não se repita ou não seja redundante.
A ideia é que você escreva código uma vez apenas e o reuse sempre que for necessário.

Na engenharia de software, o princípio DRY (não seja redundante) é usado para evitar repetição de informações e de trabalho.
“Cada peça de conhecimento deve ter uma única e não ambígua representação autoritativa dentro do sistema”. (Dave Thomas, 2003).
O princípio foi formulado pelos autores do livro “The pragmatic programmer“, Andy Hunt e Dave Thomas.
Sua aplicação inclui esquemas de bancos de dados, planos de testes, documentação etc.

A correta implementação deste princípio, implica que alterar um elemento dentro do sistema, não afeta outros elementos não-relacionados.

Programação por convenção

Este é um paradigma de projeto de software, que busca reduzir o número de decisões que os desenvolvedores precisam tomar — tornando o processo mais simples mas, nem por isso, menos flexível.
Assim, o programador só precisa especificar aspectos não convencionais da aplicação.
Por exemplo: havendo uma classe Vendas, dentro do modelo, a tabela correspondente, dentro do banco de dados, vai se chamar também “vendas”, por padrão.
Código “extra” relacionado a estes nomes, só vai precisar ser escrito, se alguém usar um nome diferente pra tabela.
Se pensar bem, é muito simples.
Leve em consideração um formulário:

  • ele tem elementos que sempre são requeridos;
  • estes elementos têm estados que, comumente, são os mesmos;
  • Um formulário, em meio ao código HTML, tem uma tag <form> que especifica uma ação a ser tomada, um método, um nome, uma id etc.
    Se você não precisa alterar nada, é mais fácil obter logo o nome do form, seu id, ação etc. direto da url.

Aplicar esta ideia a todos os elementos torna a construção deste tipo de aplicação muito fácil, rápida e simplificada.

Conclusão

O assunto não se esgota neste artigo — e pretendo retomá-lo em outros posts.
Tal como foi dito, até aqui, o MVC é uma maneira de começar a produzir de maneira limpa, escalável e robusta — e escrever código rápido, no menor espaço de tempo possível, com o mínimo de esforço.
Alguns frameworks MVC possuem apenas um ou dois destes recursos. O conselho é experimentar até encontrar um que te sirva.
Como sempre, sinta-se à vontade para comentar e compartilhar sua experiência comigo e com os outros leitores.

Leia mais

http://c2.com/cgi/wiki?BusinessLogicDefinition
http://pt.wikipedia.org/wiki/Padr%C3%A3o_de_projeto_de_software