Em todos os anúncios para programador PHP encontro:

Precisa-se de programador que saiba PHP e:

- Banco de dados MySQL, Oracle, PostgreSQL, etc…
- Saiba FLEX, JAVA, C# (diferencial Kringol)
- Saiba HTML, JavaScript, AJAX, …
- Aptidão para webdesign, Corel, Pagemaker, Photoshop …

Afinal, é para PHP ou para um super faz tudo?

Tantas exigências, que no mínimo, deve-se tratar de uma empresa terceirizada da NASA.

Mas será que a gerência desta empresa esta preparada para um profissional com estas qualificações?

Gerentes que não tem o menor conhecimento técnico geralmente ficam encarregados de entrevistar os programadores.
O procedimento é o mesmo, verificam se as siglas do currículo estão de acordo com a descrição do cargo, e pronto, o programador já esta contratado. Claro que o a pretensão salarial baixa sempre é bem vinda para critérios de desempate.

Quando a vitima, digo, o programador inicia suas atividades na empresa, ele ao menos pensa que vai encontrar um ambiente de desenvolvimento, algum tipo de documentação inicial, para ajuda-lo a entender as regras de negócios da empresa.

Mas a realidade não é assim. É comum encontrar sistemas “Macarrõnicos” com metodologia POG (Programação Orientada a Gambiarra) .

< Dramatização >

As melhores empresas para se trabalhar utilizam metodologias POG, vejam os benefícios:

Todos códigos são desenvolvidos no ambiente de produção, e ainda com o cliente testando ao mesmo tempo. Assim evita-se perda de tempo com copias redundantes do código e equipamentos de backup.

Todos os programadores acessando os mesmos arquivos ao mesmo tempo. Nada melhor do que bloquear o acesso do arquivo para ter certeza que ninguém vai alterar o código.

Padrões de backup sempre são avançados:

pagina_principal.php
pagina_principal.bkp.php
pagina_principal2.php
pagina_principal___ontem.php
pagina_principal_Joazinho.php

Os comentários são a base do sistema, sempre poucos e explicativos
// XUNXO do chefe para poder funcionar esta parte (Não mexa)

if(1==1)
{
    $variavel = 1;
}else{
    $variavel = 0;
}

Teste?
A sim, sempre tem o cliente para testar dois dias antes de entregar o sistema. Fazemos assim porque temos certeza que o sistema sempre estará funcionando.

Escopo, script de teste?
Perda de tempo, o cliente já sabe o que ele quer. Ele lembra perfeitamente do que ele pediu ao longo dos 6 meses de desenvolvimento.
Qualquer problema esta na documentação, aqueles 500 e-mails da caixa postal de cada programador. Basta juntar todos usando EQL (E-mail Query Language) e logo esta tudo indexado.

Segurança?
Sim, temos as senhas seguras, a quais sempre passamos por POST nos input hidden dos formulários. Mas com firewall instalando antes do servidor estamos super seguros. Nunca atualizamos o servidor, a mais de 7 anos, pois nunca deu problema. Outro motivo de nunca atualizar, é para não ter perigo de quebrar a compatibilidade com PHP3.

< /Dramatização >

Infelizmente esta é uma realidade que vem me assustando ao longo dos anos, ao trabalhar com programação.
Quando acho que vou encontrar uma empresa que ao menos use um ambiente de desenvolvimento e versionamento, fico decepcionado.
Os códigos não me assustam mais, já superei alguns traumas:
- if(1==1)
- if(1==2)
- sleep(60) (acredite, você não vai querer saber o motivo)
- do{ POG de 3000 linhas com identação de mais de 40 if elses + paçoca de HTML + JS + CSS e milhares de consultas a banco} while(150000);
- dar um show tables; e vir uma listagem de 56 mil tabelas (é criado uma tabela para cada acesso ao sistema ao invés de um registro em uma tabela)
- chefe ter ‘xilique’ que o HTML não abre no Front Page , e quase te mandar embora quando você fala a palavra CSS e tableless

O que mais me assusta é a incapacidade da gerencia de permitir que você melhore o ambiente de trabalho, implementando metodologias de desenvolvimento.

< Dramatização >

Quer ser mandado embora de uma empresa que utilize de metodologias POG?

Simples, siga meus conselhos:
- Comece a falar que GIT é legal e melhor que SVN, se possível mande por e-mail par ao chefe todas as reportagens que explicam tecnicamente porque GIT é bom.
- Instale um servidor de desenvolvimento, caso lhe digam que não tem máquina, ofereça o seu desktop, enquanto isso você pode trabalhar em algum note da empresa, até comprarem outro desktop para você.
- Peça ajuda por e-mail, quando tiver dúvidas sobre as regras de negócios, dizendo que você esta com dificuldades de entender o que a sequencia de 40 if else tem que fazer.
- Utilize metodologias de Refatoração, se possível tente implementar Testes Unitários e OO.
- Instale o Redmine integrado com o GIT, e comece a organizar suas tarefas e a documentar as coisas.
- Utilize XDebug para entender melhor sobre o que esta acontecendo com o macarrão, digo código, e manda um e-mail para o chefe mostrando sua benfeitoria.

Caso você não seja demitido, e sofra apenas uma intervenção leve, infelizmente sua empresa tem chances de implementar alguma metodologia Ágil. Sinto muito.

< /Dramatização >

Os gerentes quase sempre cometem um erro básico, contratam o programador sem perceber se ele vai se adequar a sua metodologia de trabalho, ou seja , a falta dela.
Outro erro comum, é não explicar como será o ambiente de trabalho. E o pior, não consultar a equipe para ver se o novo candidato tem o perfil que se adeque a equipe.
Não tem regras para estes fatores, tem apenas bom senso, e é isto que esta faltando.

Eles não entendem que não tem como regredir.
Depois que você tem contato com frameworks, MVC, OO, GIT, Redmine, XDebug, Padrões de Projetos, Teste Unitário e metodologias Ágeis, não tem como voltar atrás.
Fica quase impossível trabalhar em um ambiente que não aplique ao menos parte destes conhecimentos. Ou que sejam resistentes a mudanças e quebra de paradigmas.

Perdi a minha oportunidade de ir para o FISL 11. Fui demitido por ter instalado um servidor de desenvolvimento com GIT + Redmine e utilizar XDebug para entender um código abençoado.
Segundo a gerência, eu estava perdendo tempo instalando “coisinhas” ao invés de estar lendo o código abençoado e adivinhando as regras de negócio da empresa (isso tendo apenas 2 semanas de empresa).
Nenhuma das solicitações de ajuda por e-mail foram respondidas. Segundo a gerência, sendo eu um programador PHP, apenas vendo o código abençoado, já deveria entender todas as regras de negócios da empresa. Assim como qualquer bom POGramador faria.

Desculpem o desabafo, mas perder o FISL 11 por tentar melhorar as condições de trabalho da empresa, me deixou muito chateado.

Por que usar Pidgin?

- Multiplataforma
- Simples (sem frescuras)
- Vários plugins
- Vários protocolos

Pessoalmente eu uso ele por conseguir usar todas as minhas contas ao mesmo tempo (MSN, Gtalk e IRC).

Para entrar no canal IRC do #php-curitiba

Servidor: irc.freenode.net
Canal: #php-curitiba
Comando no pidgin: /join #php-curitiba

Baixar o pidgin:

Objetivo

O objetivo deste tutorial é ensinar a criar um Servidor SOAP, utilizando
a biblioteca do Zend Framework.
Pedi para o meu amigo Artista Frustrado, elaborar uma introdução a webservice, e fazer exemplos em outras linguagens, confira.

Material

Componentes do Zend Framework:

• Zend_Loader
• Zend_Soap
• Zend_Soap_Client
• Zend_Soap_AutoDiscover

Arquivos soap.tar.bz2:

/index.php
/client.php
/Client
    /Calculadora.php
/Server
    /Calculadora.php
    /ServerSoap.php
/README

Testado no seguinte ambiente:

• Versão do Zend Framework testada: 1.7.5
• Sistema Operacional: Linux
• Distribuição: Debian Lenny
• Versão do PHP: PHP 5.2.6-1+lenny2
• Versão do Apache: Apache/2.2.9 (Debian)

Material recomendado para leitura:

• Orientação a Objeto no PHP5
• Zend_Soap
• Serialize
• Web Services Essentials
• Programming Web Services with SOAP

SOAP

O SOAP é um protocolo de comunicação entre o web service e o cliente. Suas especificações não são simplesmente uma transferência de XML basica, são envolvidas diversas regras para aplicações em diveras plataformas e formatos de XML.

Quando utilizar SOAP?

Quando você não quer disponibilizar a apresentação da camada so seu aplicativo, e sim, apenas algumas funcionalidades, evitando abrir conexões com bancos.

Quando você tem que iteragir com outros sistemas homogeneos. Exemplo, o seu fornecedor tem uma aplicação em .NET e precisa acessar uncionalidades do seu sistema que é feito em PHP. Assim, temos linguagens, sistemas operacionais e banco de dados diferentes podendo se comunicar.

Quando você quer centralizar as regras de negócios no servidor. Usando clientes que acessam o servidor, sendo eles qualquer dispositivo (PDA, Terminal, celular etc.)

Configurando o Ambiente

Temos a seguinte estrutura de pastas:

/soap
    /index.php
    /client.php
   /Client
        /Calculadora.php
    /Server
        /Calculadora.php
        /ServerSoap.php
    /README
/zf

Na pasta soap é aonde ficam os arquivos e na pasta zf a biblioteca do Zend Framework.

- Descompacte o arquivo soap.tar.bz2 na sua pasta web (no meu caso foi na pasta /var/www)

- Configure o apache para apontar para a pasta do soap
No Linux:

    ServerName soap.localhost
    DocumentRoot /mnt/dados/www/soap

- Adicione no arquivo hosts: 127.0.0.1 soap.localhost
No Linux: adicione a linha no arquivo /etc/hosts

- Reinicie o apache

- Teste no browser os endereços:
– http://soap.localhost
– http://soap.localhost?wsdl

- Finalmente execute o cliente:
No Linux:

:# php cliente.php

Deve aparecer a seguinte resposta:
##############################

Lista das funções disponíveis:
array(3) {
  [0]=>
  string(12) "string ola()"
  [1]=>
  string(25) "int somar(int $a, int $b)"
  [2]=>
  string(45) "string objeto(string $objeto, string $metodo)"
}

ola() -> Oi

somar(2,2) -> 4

calculadora->somar(3,3) -> 6

calculadora->naoexiste() -> O método: naoexiste() não foi implementado.

##############################

Pronto você já esta usando SOAP.

Exemplo

O nosso exemplo consiste em um servidor web rodando um web service em PHP com Zend_Soap_Client Zend Framework, e um cliente também em PHP que acessa a mesma máquina através do console, no endereço http://soap.localhost.

O cliente deve solicitar ao servidor algumas funções, e obter suas respostas.

O arquivo index.php contém o código para a criação do arquivo WSDL e do servidor SOAP.
O Zend_Soap_AutoDiscover cria o arquivo WSDL para o servidor SOAP.
O Zend_Soap que executa as funções cadastradas no WSDL, por isso que é passado por parâmetro a url http://soap.localhost/index.php?wsdl .

arquivo index.php

set_include_path(
    '../zf/ZendFramework-1.7.5/library/'
    . PATH_SEPARATOR . get_include_path()
);

require_once "Server/Calculadora.php";
require_once "Server/Soap.php";
require_once "Zend/Loader.php";
Zend_Loader::registerAutoload();

ini_set("soap.wsdl_cache_enabled", 0); //** Limpa o cache

if(isset($_GET['wsdl'])) {
    //** Cria o arquivo WSDL automaticamente
    $autodiscover = new Zend_Soap_AutoDiscover();
    $autodiscover->setClass('ServerSoap');
    $autodiscover->handle();
} else {
    //** Executa o servidor SOAP
    $soap = new Zend_Soap_Server("http://soap.localhost/index.php?wsdl");
    $soap->setClass('ServerSoap');
    $soap->handle();
}

IMPORTANTE: Deve-se colocar o tipo de dados que os métodos recebem e retornam usando os tipos de dados do PHPDOC. Veja nos comentários do exemplo.

arquivo Server/Soap.php

class ServerSoap
{
    /**
     *  @return string
     */
    public function ola()
    {
        return "Oi";
    }

    /**
     * @param int $a
     * @param int $b
     * @return int
     */
    public function somar($a,$b)
    {
        return $a + $b;
    }

    /**
     * Executa uma classe vinda do cliente.
     *
     * @param string $objeto
     * @param string $metodo
     * @return string
     */
    public function objeto($objeto, $metodo)
    {
        $tmp = unserialize($objeto);

        //** Verifica se o método existe para o $objeto
        $class_methods = get_class_methods($tmp);
        foreach ($class_methods as $method_name) {
            if($method_name == $metodo)
            {
                $tmp->$metodo();
                return serialize($tmp);
            }
        }

        $tmp->msg = "O método: {$metodo}() não foi implementado.";
        return serialize($tmp);
    }
}

O Zend_Soap_Client conecta no servidor SOAP, passando a url do WSDL. Para acessar as funções cadastradas basta a variável instanciada e o nome da função.

arquivo client.php:

set_include_path(
    '../zf/ZendFramework-1.7.5/library/'
    . PATH_SEPARATOR . get_include_path()
);

require_once "Client/Calculadora.php";
require_once "Zend/Loader.php";
Zend_Loader::registerAutoload();

ini_set("soap.wsdl_cache_enabled", 0); //** Limpa o cache

//** Inicia a conexão com o cliente
$client = new Zend_Soap_Client("http://soap.localhost/index.php?wsdl");

echo "\n##############################\n\n";

echo "Lista das funções disponíveis:\n";
var_dump($client->getFunctions());

//** Chama a função ola()
echo "\nola() -> ".$client->ola() ."\n\n";

//** Chama a função somar(a,b)
echo "somar(2,2) -> ".$client->somar(2,2) ."\n\n";

//** Cria o objeto Calculadora e passa para o SOAP executar a soma
$calculadora = new Calculadora(3,3);

$soapCalculadora =  $client->objeto(serialize($calculadora), "somar"); //* A Calculadora tem que ser serializada antes de passar para o SOAP.
$unserializeCalculadora = unserialize($soapCalculadora); //* A Calculadora tem que ser deserializada antes de chamar o metodo resposta().
echo "calculadora->somar(3,3) -> ".$unserializeCalculadora->resposta()."\n\n"; 

$erroCalculadora = $client->objeto(serialize($calculadora), "naoexiste");//** Tentando executar um método inexistente.
$erroCalculadora = unserialize($erroCalculadora);
echo "calculadora->naoexiste() -> ".$erroCalculadora->msg."\n";

echo "\n##############################\n\n";

A classe Calculadora

Temos duas instâncias do objeto Calculadora, uma para o servidor , aonde contém o método calcular() e a do cliente aonde temos o método resposta().
Para passar o objeto Calculadora do cliente para o servidor, e depois do servidor para o cliente, usamos uma técnica chamada serialização.

Server/Calculadora.php

/**
 * Classe calculadora do servidor
 *
 */
class Calculadora
{
    public $a;
    public $b;
    public $resposta;

    /**
     * Executa a soma
     *
     */
    public function somar()
    {
        $this->resposta = $this->a + $this->b;
    }
}

Client/Calculadora.php

/**
 * Classe calculadora do cliente
 *
 */
class Calculadora
{
    public $a;
    public $b;
    public $resposta;

    /**
     * Construtor da classe
     *
     * @param int $a
     * @param int $b
     * @return void
     */
    public function __construct($a, $b)
    {
        $this->a = $a;
        $this->b = $b;
    }

    /**
     * Retorna a resposta da soma
     *
     * @return int
     */
    public function resposta()
    {
        return $this->resposta;
    }
}

Para dúvidas ou críticas construtivas entre em contato.

Data: 18/01/2008 as 19:00h
Local: Shopping Estação (ao lado do CEFET) na praça de alimentação.
Assunto: Montar um grupo de estudo de PHP.
Lista de participantes:

1) Alexandre F. Martins (Zed) – zedmaster@
2) Ricardo – sr_yaya@
3) Valmir – valmir_domingues@
4) Cristian Trentin – admderede@
5) Everton Schipfer – eveschipfer@
6) Diego Noguês – diego.sure@
7) Allan Schmitt – allanrfs@
Fernando Binasco – fernando.binasco@
9) Rodrigo oliveira – at4k3r@

Para maiores informações entre em contato MSN: zedmaster arroba hotmail.com

Ps.
programador – “Ha, mas eu nem sei mto de PHP, não vou poder colaborar. ”
Zed – “Errado, é de você mesmo que precisamos, suas dúvidas serão nossos tópicos.”

O PHP Day Jan/2008 será realizado dia 12 (sábado) Ã s 09:20 em Curitiba – PR no auditório do departamento de informática (DInf) da UFPR.

Para maiores informações consulte:

PHP Day Jan/2008 – Curitiba

Temos diversas variações de leite, leite de soja, semi-desnatado, desnatado, de cabra etc. cada um tem o seu preferido, e temos muitas fábricas que produzem os mesmos tipos de leite.
Para algumas fábricas de leite, o importante é ter consumidores, não importando o jeito que ela produz leite. Pensando assim, estas fábricas andaram alterando a composição do leite, colocando cal e água oxigenada para diminuir os seus custos. Oficialmente não morreu ninguém por causa disto, e o consumidor tomou o leite e nem percebeu a alteração, pois o que importa é que ele consumiu e gostou.
Pagamos qualquer preço para tomar o leite de nossa preferência, mas não compramos leite de uma marca supostamente alterada, mesmo não percebendo a alteração no gosto.
Não estamos questionando qual é o leite mais gostoso, e sim questionando como ele é feito, ter a certeza que os componentes e o método de fabricação não irão causar danos a saúde ao longo do tempo.
Para a fabricação de leite existem normas e métodos para garantir qualidade, dentre outros fatores. Em informática encontramos a mesma situação, principalmente que na maioria das vezes o consumidor entende mais de leite do que de informática.
Quando a parte profissional, nega-se a aceitar em sempre estar melhorando a qualidade do produto, e o que realmente importa é o cliente achar que “o leite dele não esta alterado” e pagar bem por isso, estará contribuindo para “a marca” (a linguagem PHP no caso) venha a sofrer boicotes, quando a mesma participar de uma pré seleção em um projeto de grande porte.
Se o PHP ficar circulando apenas em pequenas empresas e projetos pequenos, nunca um empresário terá condições de pagar salários maiores aos seus programadores. Uma solução seria trabalhar como autônomo para tentar ganhar mais, isto só é bom para o programador, porque o PHP ainda continuará em pequenos projetos.