FuryousCoder Pro

Meus colegas mais próximos sabem: sou adepto e fanático por metodologias ágeis, entre elas o Scrum. Formalizado por Ken Schwaber, é uma metodologia mais formal que o XP, mas menos burocrática se comparada com o CMMI. Eu diria que é o meio termo que agrada os menos xiitas. O mais legal de tudo: se aplicado corretamente, funciona. Sei por experiência própria.

O que me deixa triste no Scrum é uma "certificação" chamada CSM (Certified Scrum Master). Não sou do tipo que acredita ou preza uma certificação (não fiz nem questão do MCP por mais de 10 anos), mas não desmereço quem as tenha. Só que no caso do CSM, para conseguir a porra da certificação tudo que precisa fazer é assistir dois dias de treinamento caríssimos onde nenhuma prova é aplicada... Porra, que valor essa certificação poderia ter então???

Durante minhas navegadas acabei deparando com um excelente artigo escrito por Scott Ambler, escrito em junho de 2007 no Dr. Dobb's, onde ele expressa exatamente o que sinto em relação à esta certificação. Para quem não sabe, Ambler faz parte do Agille Manifest ao lado de personalidades como Martin Fowler e Kent Beck, os papas do Agille. Seu livro "Modelagem Agil" devia ser de leitura obrigatória nos cursos de TI. O trecho mais interessante:

The challenge that we face is that many good people have chosen to become CSMs, but their reputations are at risk of being tarnished because of the actions of others. All is not lost, there are several ways that we can take back the ethical high ground:

No lugar onde estou, estou me deparando com alguns códigos feitos no início do .Net 1.1, e acabo topando com umas aberrações que me dá vontade de entregar um Darwin Awards para quem criou isso. Tudo bem, dou um crédito para o cidadão, afinal era uma tecnologia nova e muitos vieram para o mundo .Net do VB 5 ou 6. Então programar orientado a objeto acaba sendo uma coisa que poucos se acostumaram (e muitos ainda não se acostumaram).

Uma das coisas medonhas que acabei deparando num dos projetos era a repetição de blocos gigantescos de códigos dentro dos codebehinds. 3 anos atrás, eu resolvia esse tipo de coisa criando uma classe com um monte de métodos e referenciando ela aos aspx que precisavam dela. Outras vezes resolvia com métodos embutidos em usercontrols que era compartilhada em todas as páginas. Isso resolvia o problema, mas meu amigo e colega George me mostrou um modo mais elegante de contornar esse tipo de coisa.

Imagine a seguinte situação, que é bem comum numa aplicação web. Você precisa que em todas as páginas seja executada no evento PageLoad uma rotina de autenticação onde se verifica se o usuário logado tenha ou não permissão para acessar à mesma. Iniciantes costumam fazer algo desse tipo:

using System.Web;
using System.Web.UI;

#region : e mais uma porrada de referências

namespace SampleWebSite
{
     
   public class Principal: System.Web.UI.Page
···{
······private void Page_Load(object sender, System.EventArgs e)
······{
         if(!IsPostBack)
         {
············//rotinas para autenticação
············if(Session["objUsuario"]!=null)
············{
···············cUsuario objUsuario = (cUsuario)Session["objUsuario"];
···············if(!cUsuario.TemPermissao("Principal"))
···············{
··················Response.Redirect("erro.aspx");
···············}
············}
············else
············{
···············cUsuario objUsuario = new cUsuario();
···············/*
···············
···············*/
···············Session["cUsuario"] = objUsuario;
·········   ·}
·········}
         //fim rotinas autenticação
       
         //Aqui pode estar executando outras coisas, como carregar valores defaults em textboxes, etc
      }
···}

Não é nada primoroso esse código, né? Mas creio que é simples de entender e ilustra o cenário que vamos trabalhar. Funcionalmente, não existe nada muito errado. Porém o programador resolveu replicar o trecho de autenticação em um site com mais de 60 aspx. Continua funcionando, mas por algum motivo, o método TemPermissão foi alterado radicalmente e obriga a inclusão de um parâmetro adicional. Legal para caramba, né? Só precisa abrir todas as páginas e alterar uma por uma!

Alguns podem achar que isso não pode ser real, mas o fato é que não é a primeira vez que encontro algo medonho como esse aí acima.

A solução que considero a mais elegante: crie uma nova classe, chamada basepage.cs como exemplo e monte algo assim com ela:

using System.Web;
using System.Web.UI;
#region : e mais uma porrada de referências

public class pagebase:  System.Web.UI.Page
{
···public override void On_Load(EventArgs e)
···{
······Autentica();
······base.OnLoad(e);
···}

···private void Autentica()
···{
············//Aqui boto a rotina de autenticação
············if(Session["objUsuario"]!=null)
············{
···············cUsuario objUsuario = (cUsuario)Session["objUsuario"];
···············if(!cUsuario.TemPermissao(this.Page.ToString()))
···············{
··················Response.Redirect("erro.aspx");
···············}
············}
············else
············{
···············cUsuario objUsuario = new cUsuario();
···············/*
···············
···············*/
···············Session["cUsuario"] = objUsuario;
·········   ·}
·········}

···}
}

Em seguida, altere o codebehind de todas as páginas a  declaração da classe
public class NomePagina: System.Web.UI.Page
para
public class NomePagina: pagebase

O que eu fiz? Lembram aquela aula de orientação à objeto onde o professor falava sobre herança? Foi isso que fiz. Basicamente, criei uma nova classe que herdava do System.Web.UI.Page e incrementei algumas novas funcionalidades que serão herdadas pelas outras páginas que pertencerem à nova classe (pagebase). O override On_Load vai executar a rotina da autenticação antes de executar as rotinas que forem inseridas dentro do handler PageLoad. Todos os métodos públicos, constantes, enumeradores que você colocar no pagebase estarão disponíveis para as páginas que herdarem dela.

Sabe aqueles montes de métodos que bolamos para contornar os probleminhas mais comuns, tipo formatar ou validar um valor, retornar zero em vez de nulo ou aquele javascript que é embutido na página via codebehind? Pois é, você pode coloca-los  dessa classe. Pode também colocar as constantes e enumeradores mais comuns nela. Dá para resolver muitos problemas e não precisa editar as 60 páginas toda vez que houver manutenção em alguns desses itens compartilhados.

Pensar antes de fazer qualquer coisa custa pouco e beneficia muito. O preço pago pelo comodismo e preguiça mental é altíssimo, para os outros e para você. Da próxima vez que for escrever uma aplicação, planeje um pouco. Porque depois ou você vai refazê-lo ou suas orelhas vão ficar vermelhas por causa dos comentários de quem está limpando sua bunda...

Não, não vou falar sobre futebol americano. Esta semana participei do Visual Studio 2005 Beta 1 Touchdown Training Program, no Centro XML, IPT-USP, tendo como instrutor o José Antonio Neves, da ITGroup.

Devo dizer que o produto está, no mínimo, interessante. Muito interessante mesmo, ainda que tenha uns bugs, mas vamos dar um crédito, pois é o beta 1.

Entre os novos recursos, alguns que me chamaram atenção foram as ferramentas de refactoring. Éeeee... a tal refatoração tão pregada no Extreme Programming. Definitivamente, a MS abraçou várias idéias do XP. Prova disso são o MSF Agile e os recursos do VS Team System. Suporte total ao XP mesmo.

Estes últimos meses estudei muitas coisas, acho que nem na época de estudante me esforcei tanto assim. Investi muito em livros relacionados a metodologia Agile, instalei e estou fuçando o VS2005 e o SQL Server 2005 beta, VS Express Edition e o melhor: um Pocket PC para começar a aprender a desenvolver aplicações Mobile. Sinto que é um momento que estou absorvendo informações com muita facilidade, e vou aproveitar disso enquanto essa bença durar.

Semana que vem vai ser curta. Vou estudar um pouco mais e escrever alguns artigos esclarecendo algumas facilidades que o refactoring fornece. É algo que vai aumentar muito a produtividade e a qualidade dos códigos. Até lá!

Bom, blog divulgado, mas somente 3 meses após a inauguração que estou podendo botar alguma coisa útil por aqui. Valeu Zé Luís, essa puxada na minha orelha me estimulou a dar este pontapé inicial.

Parece brincadeira. Mais de 3 anos de total envolvimento com .Net, mas conto com os dedos os webforms que tive que desenvolver. É nisso que dá em ficar bitolado apenas em desenvolvimento de componentes, serviços ou os malditos AICs do Biztalk, mas isso não vem para o caso discutido agora. Aí na primeira vez que pinta uma zica que era para ser algo corriqueira, eu ganho um transtorno por não conhecer o asp.net do jeito que eu gostaria.

DropDownList: quem já mexeu num webform sabe que ela pode gerar um combo tendo sua carga feita via um DataSet. É algo ridiculamente fácil de usar. Aí você pode me perguntar: porra, então para quê esse alvoroço todo?

Bom, lá estava eu montando meu form com alguns desses ditos cujos. Elas carregaram direitinho na página, atualizavam os outros componentes quando mudava seu SelectIndex, até que deparei com um pequeno problema: a lista continha exatamente o que tem dentro do DataSet, e se você precisa de uma primeira opção com valor nulo, daqueles que a maioria dos desenvolvedores escrevem "Selecione uma opção", teria que inseri-la no codebehind. É mole?

A preguiça sempre fala mais alto. Eu não queria tratar disso no codebehind e muito menos fazer um union dentro do stored procedure só para isso. Para falar a verdade, não aceitei bem o fato de não ter uma opção que permita mostrar uma opção nula.

Aí cometi a burrada número um: incluí um ListItem no dito cujo dentro do aspx. Desnecessário dizer que não rolou, pois durante a geração da página o codebehind renderiza o dito cujo de novo e matou o item que incluí. Sucks!

Opção número 2: pensei em incluir um javascript para fazer essa inclusão. Mas como tinha uma quantidade de combo considerável, descartei essa opção.

Aí o jeito foi trabalhar com o codebehind mesmo. E para minha surpresa, foi a maior babada.

O código final ficou algo assim:

//Aqui efetua-se a carga do combo, do jeito arroz com feijão
lstTeste.DataSource = objDataSourceTeste;
lstTeste.DataMember = "dsTeste";
lstTeste.DataValueFiels = "ID_TESTE";
lstTeste.DataTextField = "DSC_TESTE";
lstTeste.DataBind();

//Aqui mostro o texto que vou colocar no indice zero
string txtOptionZero = "Selecione um campo";

//O trabalho começa: crio o item que vou adicionar
ListItem OpcaoZero = new ListItem(txtOptionZero ,"");

//E aqui adiciono o item no combo:
lstTeste.Items.Insert(0, OpcaoZero);

Iinclusão feita, de forma ridiculamente simples. Descobrindo o jeito de fazer isso, acabei bolando um WebComponent do tipo DropDownList, mas adicionando um flag do tipo bool, que oferece a opção de carregar a opção zero. Adicionei tambêm um string que permite configurar a descrição do texto nessa classe. Daí em diante era só usar o dito cujo no lugar do DropDownList original. Fácil, fácil.

Acho que a MS devia disponibilizar algo desse naipe, e caso já exista, devia ser algo mais explícito. Quanto a mim, concluí que cachorro velho pode aprender truques novos e que sou capaz de elaborar coisas decentes em webforms.

Por hoje é só. Abraços.

Em primeiro lugar, digo e afirmo: blog é coisa de viado. Mas antes de querer montar em cima de mim para me sacanear seria interessante entender meus motivos.

As razões pelas quais estou montando este treco:
1) Estou abismado em ver muita gente que codifica muito pior do que eu, sendo que eu já me considero um programador mediocre.
2) É um desafio para mim mesmo, pois escrever artigos técnicos não é a coisa mais fácil do mundo. Fazer a manutenção então...
3) Vão poder acompanhar o dia a dia de um cidadão tentando se certificar como MCSD e ver as coisas novas que estou aprendendo.
4) Não é para ser um blog. Entenda isto como um jornalzinho técnico. Infelizmente meu bolso não me permite montar algo decente com um Sharepoint ou um CMS da vida, então vale o velho ditado: quem não tem cão caça com rato. Isso mesmo, rato!!!

Sendo assim, acho interessante passar os tips & tricks e alguns best practices que adquiri nos últimos tempos, seja por aprendizagem própria, seja nos projetos que desenvolvi com o povo da MS. É uma pequena contribuição para tentar melhorar o nível dos profissionais do mercado.

Espero que possa aproveitar bastante com os artigos. Se ainda quer me sacanear, vou pedir para os deuses que você tenha que configurar Linux gratuitamente pelo resto da sua miserável vida.

Marco Chen