Ontem teve fim uma experiência muito bacana que tive aqui na Stefanini: assumi, com apoio do time de arquitetura (Raphael Nascimento – @raPHaelrn, Felipe Castro – @felipec_castro e Victor Cavalcante – @vcavalcante), uma turma de formação de profissionais de análise e desenvolvimento na plataforma .Net.

A idéia era captar talentos do mercado e disseminar os conhecimentos e cultura do SDC (Software Delivery Center da Stefanini). Estudantes do 1º ao 3º semestre (se não me engano, estou certo moçada?).

Durante o curso, falamos de orientação à objeto, orientação à eventos, banco de dados, entre outras coisas… Desenvolvemos uma calculadora, um cadastro simples e por fim um “Bank line”. Foi tudo bem legal, eu curti muito a experiência e espero que, os que ainda posso chamar de “meus alunos”, também tenham gostado e que tenham suas expectativas atingidas.

Algo bem legal que posso contar é que eu costumava dizer que eu estava ensinando a eles “como não fazer” algumas coisas. Claro, com o objetivo de que eles buscassem estudar sobre qual seria a forma correta de chegar ao mesmo objetivo, que fossem atrás. O @vcavalcante fazia até algumas participações especiais nas aulas, chegando de surpresa e dizendo “É isso aí que ele está ensinando pra vocês? Está tudo errado!” – É claro que nestas aulas eu falava de HTML, JavaScript, ASP.Net WebForms

Abaixo, algumas fotos do último dia de aula. (Clique para ampliar)

Espero vê-los novamente num futuro próximo! Sucesso à todos e “ganbatte” *.

*Do japonês: Do your best, go for it (esforce-se, dê seu melhor)

No post anterior, falamos de uma customização de work items usando os recursos do próprio Visual Studio somados aos do Team Foundation Server Power Tools. O que faremos seguindo esse guia é ir além, codificando nosso próprio controle para um formulário de work item.

Vamos relembrar o problema que vamos resolver: precisamos de um campo que vai exibir o andamento geral da atividade, baseado no andamento das 3 etapas, consolidando-as. Para mais detalhes, você pode ler mais sobre o problema proposto na Parte 1.

Para acompanhar, todo o código conte e XML de definição do Work Item “Task” está disponível para download neste link.

Como funciona o deploy de novos controles para Work Items?

Diferentemente do que muitos me supõe, os assemblies de controles customizados para work items não ficam dispostos no servidor do TFS, mas sim em uma pasta específica em cada máquina cliente. Essa pasta é:

[Drive]:\programdata\Microsoft\Team Foundation\Work Item Tracking\Custom Controls\10.0

Por conta disso, precisamos escolher uma forma para distribuir nosso assembly do controle. Isso fica a seu critério. Você pode disponibilizá-la para cópia num compartilhamento na rede, distribuir via pendrive, SkyDrive, etc… Eu escolhi criar um setup que já faz a cópia da DLL para o diretório correto, e aí sim compartilhei este na rede, porém, não vamos entrar nesse mérito.

Vale lembrar que depois do deploy da DLL feito nessa pasta, é necessário reiniciar o Visual Studio para que ele faça sua leitura.

Vamos ao que interessa

Para criarmos nosso controle, criamos um Class Library simples dentro do nosso Visual Studio. Vamos chamá-lo de CustomWorkItemFields. Chamei assim porque, dentro desse mesmo assembly, podemos criar outros novos controles.

Dentro dele, adicionamos um User Control, que vou chamar de “PercentComplete”. Adicionamos então um TextBox simples, o qual vamos chamar de “txtValue”. O último passo dessa parte visual é ajustar o form para que ele fique do mesmo tamanho que nosso TextBox, assim:

Agora, precisamos implementar a inteligência desse controle. Para isso, vamos ao código.

Antes de tudo, precisamos adicionar duas referências ao nosso projeto, que são:

• Microsoft.TeamFoundation.WorkItemTracking.Client, parte do Team Foundation Server SDK
• Microsoft.TeamFoundation.WorkItemTracking.Controls, localizado no diretório:

[Drive]:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\PrivateAssemblies

Feito isso:

-          Faça as referências a esses namespaces no codebehind do controle;

-          Implemente a interface IWorkItemControl;

-          (Opcional, como implementei) crie um struct para organizar os nomes dos campos de work items com os quais vamos trabalhar os cálculos;

-          Crie o método SetPercenteCompleteField() para concentrar a inteligência de cálculo.

O segredo todo desta customização está no evento FieldChanged do WorkItem, porque a cada vez que um campo for modificado e este for um dos 3 novos campos que adicionamos ao formulário, temos que realizar o cálculo e exibir o resultado no nosso controle customizado. Veja como ficou o núcleo da nossa customização, o método “SetPercentCompleteField”:

private void SetPercentCompleteField()
{

try

{

// Obtém todos os valores que estão informados nos nossos campos de acompanhamento

var analysis = int.Parse(_workItemDataSource.Fields[WorkItemFields.Analysis].Value.ToString().Replace("%", string.Empty));

var development = int.Parse(_workItemDataSource.Fields[WorkItemFields.Development].Value.ToString().Replace("%", string.Empty));

var tests = int.Parse(_workItemDataSource.Fields[WorkItemFields.Tests].Value.ToString().Replace("%", string.Empty));

// Aplica os pesos a cada um dos valores e depois obtém porcentagem

var result = analysis*40;

result += development*30;

result += tests*30;

result = result/100;

// Atribui o resultado ao nosso campo de work item para armazenamento na base de dados

_workItemDataSource.Fields[WorkItemFields.PercentComplete].Value = result;

// Atribui esse resultado, formatado com o caractér '%', no campo do controle

txtValue.Text = result + "%";

}

catch (Exception)

{

if (_workItemDataSource == null) return;

_workItemDataSource.Fields[WorkItemFields.PercentComplete].Value = 0;

txtValue.Text = "0%";

}
}

Depois do controle codificado, precisamos agora criar um arquivo de definição do controle de work item, que será colocado na mesma pasta de deploy que informei acima. Veja o seu formato:

<?xml version="1.0"?>
<CustomControl xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Assembly>ALMTeam.BlogSampleCMMi.CustomWorkItemFields.dll</Assembly>
<FullClassName>ALMTeam.BlogSampleCMMi.CustomWorkItemFields.PercentComplete</FullClassName>
</CustomControl>

Formato simples, não? Dentro da tag “Assembly”, informamos qual o nome da DLL onde está localizado nosso controle e, em “FullClassName” o nome completo, incluindo namespace, da classe que o define.

Por último, abrimos o Work Item Type “Task” e criamos o campo BlogSampleCMMi.Tracking.PercentComplete (Integer) para armazenar os dados que nosso controle vai exibir.

Feito isso, fazemos o deploy dos dois arquivos na nossa referida pasta e depois reiniciamos o Visual Studio. A partir de então, um novo tipo de controle ficará disponível para inserirmos no layout do work item. É com ele que vamos criar o campo percent complete no formulário, assim como criamos os outros 3 campos, com a seguinte diferença:

Veja que em “Type”, temos nosso tipo de controle customizado disponível. Não podemos nos esquecer, porém, que devemos também referenciar nosso campo de work item (criado na aba “Fields”) na propriedade “Field Name”.

Depois de criado o controle, salve o seu work item type e veja o resultado criando um novo work item do tipo “Task”:

Perceba que cada vez que um desses 3 campos tem seu valor alterado, o cálculo no campo “Andamento Geral” acontece automaticamente.

Importante: a implementação de um controle customizado para formulários de work items na web (Team Foundation Web Access) é diferente. Logo, verá que esse controle não é visível nos formulários web. Este assunto será abordado num outro post.

É isso galera! No próximo episódio dessa “saga”, veremos como integrar tudo isso à um cronograma do Project.

[]’s

Ricardo Serradas

Há alguns dias atrás passei por uma série de situações curiosas, com algumas diferentes customizações de um template de processo MSF for CMMi 5.0 do TFS para um time de desenvolvimento, situações essas que são relativamente simples, mas achei que caberiam bem em alguns posts sobre como realizar cada etapa. Minha proposta então é expor o problema e depois, numa série de posts, mostrar como é possível implementar tudo isso. Vamos lá.

- Há a necessidade de customizar o template do work item do tipo Task, com 3 campos que compunham o andamento de cada etapa da atividade. Algo parecido com o seguinte:

 Então, os campos “Original estimate”, “Remaining work” e “Completed work” seriam inutilizados a pedido da própria gestão.

- O próximo passo é criar um campo abaixo que mostrasse o andamento geral da atividade, uma porcentagem consolidada, levando em consideração os pesos de cada etapa. Exemplo, se:

 Logo, o andamento geral da atividade é 55%, porque ((100*40)+(50*30)+(0*30))/100 = 55, certo?

Porém, como fazer isso apenas com as regras de campos de work items do TFS? Bingo! Não é possível. Para conseguirmos isso, precisamos criar um controle customizado para nossos work items com essa inteligência embutida.

- Depois disso, sabemos que esses work items serão mapeados para um cronograma no MS Project. A necessidade do gestor é que esse campo com o andamento geral da atividade fosse refletido no campo “% Complete” do cronograma.

- Por fim, é interessante conseguirmos elaborar relatórios a partir desses novos dados. Vamos então criar um novo tipo de Report e publicá-lo na área de relatórios do Team Project.

Vamos resolver esses “puzzles”?

Parte 1: Criar campos customizados para o formulário de work item

Antes de tudo, precisamos ter um um Team Project configurado com MSF for CMMi 5.0 para podermos trabalhar. Recomendo fortemente que crie um Team Project exclusivo para exercícios como esse.

Existem duas formas para customizar um tipo de work item: editando suas definições via XML ou usando o Process Editor integrado no Visual Studio, módulo contido no Team Foundation Power Tools, que pode ser obtido neste link. Mesmo que queira mexer direto no XML, é muito importante baixar e instalar essa ferramenta para que possa ter fácil acesso ao XML definition do work item.

Depois de instalado, vamos primeiro dar uma olhada no XML definition do Work Item do tipo Task. Para isso, dentro do Visual Studio, siga os passos:

Menu Tools -> Process Editor -> Work Item Types -> Export WIT.

Uma janela como essa sera aberta:

Selecione o tipo “Task” do seu Team Project e clique em OK. Agora, você verá uma caixa de diálogo de “Salvar como”, pedindo para escolher o local para salvar o arquivo XML.

Depois de salvo, abra este arquivo com seu editor de textos preferido. Verás um arquivo de cerca de 550 linhas. Vamos falar rapidamente sobre algumas tags importantes desse arquivo:

WORKITEMTYPE – Raiz do tipo do work item. É onde, por exemplo, o nome do tipo do work item é definido.

FIELDS – Aqui são definidos os campos usados no formulário do work item. Aqui algumas propriedades são definidas, como nome do campo, tipo de dado e formato no relatório.

WORKFLOW – Neste trecho é definido o ciclo de vida do tipo de work item. Transições entre estados, campos a serem preenchidos nelas, entre outras coisas são definidos aqui.

FORM – Aqui é definida a aparência do formulário do work item. Posições de campos, tamanho, label, agrupamento, etc.

Mas, há uma frase que acho muito valiosa que Ramon Durães costuma usar, que é “Não tem que ser difícil”. Seguindo essa linha, nós vamos basear nosso trabalho em cima do Process Editor do TF Power Tools.

Vamos então abrir o mesmo arquivo XML numa interface amigável dentro do Visual Studio. Para isso, siga esse caminho: Menu Tools -> Process Editor -> Work Item Types -> Open Work Items From File. Uma janela de abertura de arquivo vai aparecer, selecione o arquivo XML que visualizávamos no editor de texto. Verás então uma janela como essa:

As abas representam os nós daquele XML que falamos acima. Para executarmos a nossa primeira tarefa, precisamos seguir o seguinte roteiro nessa janela:

- Etapa 1: Criar a definição dos campos na aba “Fields” (seus nomes, tipos e descrição).

                Usando o botão “New”, a seguinte janela aparecerá:

Entendendo esse formulário:

Aba “Field Definition”

Name – Simplesmente o nome do campo, não interfere no funcionamento.

Type – Como o nome já diz, o tipo de dado que o campo vai suportar.

Reference Name – É através desse nome que ele será usado tanto no formulário quanto nos relatórios. Tem como padrão ter um nome semelhante ao namespace+nome de uma classe. No nosso exemplo usamos “BlogSamplesCMMi.Tracking.Analisys”.

Help Text – Texto que serve para tooltips, descriptions, etc.

Reportable – Se você pretende usar a informação desse campo em relatórios, é importante escolher um dos valores para esse campo. Os valores podem ser:

                None: Não será inserido no banco de dados relacional (não poderá ser usado em relatórios);

                Dimension: Use este tipo apenas para Integer, Double, String ou DateTime. Os dados nesse campo entram no banco de dados relacional e no cubo como um atributo de dimensão do Work Item para que os dados sejam usados para filtrar relatórios. Use-o para campos que têm uma lista de valores válidos. Work Item Type e State são bons exemplos de uso desta opção.

                Detail: Use esse tipo somente para Integer, Double, String ou DateTime. Os dados nesse campo entram no banco de dados relacional nas tabelas “Work Item History” e “Current Work Item”, mas não no cubo. Esta é uma boa escolha para campos de texto sem restrição, no entanto, você terá que usar a base relacional em vez do cubo. “Summary”, um campo String que contém uma breve descrição de um work item, é um bom exemplo de campo que deve ser do tipo Detail quando usado em relatórios.

                Measure: Use este tipo somente para campos Integer ou Double. São usados para propósitos estatísticos ou para medir certos aspectos do projeto. Cada campo desse tipo aparecer tanto no grupo de medidas “Current Work Item” quanto “Work Item History”. “Estimated Work” é um bom exemplo de campo do tipo Measure.

                Apesar do campo “Formula” existir nesse form com diversas opções, os campos desse tipo são sempre agregadas como Soma (Sum).

Vamos repetir o uso desse formulário para nossos 3 campos, que nomearei assim:

• BlogSampleCMMi.Tracking.Analysis
• BlogSampleCMMi.Tracking.Development
• BlogSampleCMMi.Tracking.Tests

Aba “Rules”

Nessa aba são definidas algumas propriedades do seu campo, como valor padrão, valores permitidos, validações. O que vamos configurar em todos esses campos são as seguintes regras:

REQUIRED – O campo não poderá ficar em branco;

ALLOWEDVALUES – Deixaremos esses campos serem preenchidos somente com os valores “0%”, “50%” e “100%”.

DEFAULT – Em um novo Work Item, é o valor inicial do campo. Vamos configurá-lo da seguinte forma:

                From: value

                Value: 0%

- Etapa 2: Inserí-los no formulário do work item, através da aba “Layout”.

Essa etapa, apesar de ter uma interface amigável, não é tão intuitiva quanto arrastar controles para um Windows Form, mas claro, é muito melhor do que fazer isso direto no XML. J

Para usarmos nosso campo, primeiro precisamos escolher onde vamos colocá-lo no nosso formulário. Eu escolhi criar uma nova aba, chamando-a de “Etapas” e lá eu coloco somente os meus campos, para não poluir outras áreas do formulário. Veja a tela de layout do Work Item Type:

Na árvore à esquerda, os elementos do formulário são organizados numa estrutura de árvore e, à direita, as propriedades do elemento selecionado.

Nessa árvore, existem alguns tipos de elemento. Vamos entendê-los já praticando.

Dentro do TabGroup, criaremos um novo elemento do tipo “TabPage”. Para isso, botão direito em cima do item TabGroup -> New Tab Page. Um novo item na árvore aparecerá. Do lado direito, uma das propriedades chama-se “Name”. Altere-a para “Etapas”.

Para que os controles não fiquem espalhados dentro da aba, criamos um elemento do tipo “Group” para inserir os controles dentro. Insira então um “Group” ao TabPage usando o menu de contexto já usado acima. Quando um Group é criado, um item do tipo Column é criado dentro dele automaticamente.

Agora já podemos inserir nossos controles dentro da aba. Para isso, use o “New Control” dentro do menu de contexto em cima do item “Column”. Um novo item aparecerá como filho da Column. Ao lado direito, algumas propriedades chave do controle precisam ser modificadas. Vamos à elas:

FieldName: É aqui que você deve encontrar a Reference Name do campo que quer inserir. Neste primeiro caso, procuramos por “BlogSampleCMMi.Tracking.Analysis”.

Label: O label para o campo no formulário. Vamos usar “Análise e documentação (peso: 40%):”

Fazemos isso para os nossos 3 campos. Você pode visualizar préviamente como está ficando seu formulário, através do botão “Preview Form”, mas já adianto que não funciona muito bem. Por algum motivo, o que ele mostra não é exatamente como vai ficar seu formulário. L

Depois de pronto, salvamos o arquivo. Precisamos agora importá-lo devolta para o TFS. Para isso, vá ao menu Tools -> Process Editor – > Work Item Types -> Import WIT. Em “File”, localize o arquivo que você editou e em “Project to Import to” selecione o Team Project para o qual a customização se aplicará. Clique então em OK. Aguarde até que a importação seja concluída.

É importante agora dar um refresh no seu Team Explorer para que os templates sejam recarregados. Após isso, abra o formulário de criação de nova task e já verá a nova aba e os campos dentro dela, assim:

Primeira etapa completa! Logo mais, o segundo post falando sobre a criação de controle customizado.

[]’s

Ricardo Serradas

Esse post é fruto de um susto muito grande que tomei depois de abrir o link que o André Nascimento postou em seu twitter, uma subpágina do site do PMI onde ficou exposto o posicionamento do Instituto à respeito dos métodos Ágeis. A página em questão pode ser acessada neste endereço.

Acho que a falta de argumentos e conhecimento em relação à cultura ágil os levou a escrever essa série de textos sem fundamento. Fiz a tradução de cada um deles para que pudéssemos discutí-los melhor:

Agile é uma cura milagrosa?

Apesar da badalação, Agile não é uma cura para tudo. Contudo, não que ela seja uma metodologia que não seja adequada para tocar um projeto, mas é a cultura corporativa que pode não ser propícia para os riscos e problemas que podem surgir com Agile.

Observação: Concordo quando dizem que Agile não é a cura para tudo, o próprio movimento Ágil é ciente disso. Porém, até aqui fiquei esperando quais riscos e problemas que o Agile poderia (veja, sendo Agile o causador) trazer para dentro de uma corporação…

Tudo junto agora

Gerenciamento de projetos Agile funciona melhor quando os times estão localizados no mesmo escritório.

Não importa que metodologia você usa, é sempre muito melhor ter as equipes num mesmo espaço físico em ocasiões como reuniões de kickoff e reviews periódicos.

Observação: Qualquer metodologia, framework ou modo de trabalho, que seja, funciona melhor se os membros do time estão num mesmo espaço físico. Mas denovo, fiquei esperando argumentos provando que Agile não funciona com membros do time dispostos em escritórios diferentes.

Uma questão de confiança

Para a Agilidade funcionar, os gerentes de projeto precisam sentir-se confortáveis em delegar muita responsabilidade para os membros do time, os quais também devem confiar uns nos outros.

Então você poderá esperar um pouco para aplicar metodologias ágeis, até que a confiança tenha sido estabelecida em toda a equipe.

Observação: penso algumas coisas à respeito dessa colocação:

                – Não há um Gerente de Projeto delegando confiança, atividades, ou qualquer que seja a coisa dentro de um time ágil. O que há, de uma forma geral, é um “dono do projeto”, o qual expõe suas necessidades para o time, para que os membros deste definam a melhor forma de atendê-las.

                – Supondo que o GP exista e que estivéssemos num cenário que trabalha sob o modelo comando-controle: delegar uma tarefa à alguém não é, de fato, delegar responsabilidade? Quanto tempo o GP vai esperar para delegar uma tarefa à alguém que ele acabou de contratar? Existe um período para “aquisição de confiança” para um membro recém-contratado, onde ele fica no escritório só de papo com o GP até que a confiança “nasça”? Se executar determinada tarefa não exige responsabilidade, que valor ela tem para o negócio/produto?

Está disposto a adaptar-se?

Metodologias ágeis sozinhas não vão levar uma organização ao sucesso, mas vão identificar diversas questões e problemas que precisam ser abordadas para que os projetos sejam melhores entregues.

Observação: Sim, de fato. E que mal há nisso? Na verdade, pergunto-me: isso não é MUITO bom? Acho que toda e qualquer organização deve estar disposta e ser capaz de adaptar-se, pois o mercado é mutante e, se não houver adaptação, a corporação vai ficar para trás, assim como se um time não se adaptar às necessidades do produto, ele não terá sucesso.

Quem fez CSM, viu o exemplo da Sogra? Nesse exemplo, o trainer diz que o Scrum é a sogra que entra na casa do casal, que é chata e vai apontando todos os problemas, os móveis empoeirados, as louças empilhadas, etc. Mas quem tem que arrumar isso? O casal (time)!

Disponibilidade para experiências

Sua organização valoriza experimentações? Agile conta com um baixo custo de experimentação, permitindo uma exploração iterativa e adaptável. Simulações, prototipações e testes ajudam a recolher informações valiosas sobre o projeto.

Observação: acho que esse ponto está paralelo com o abordado anteriormente. Para adaptar-se, é necessário experimentar, inspecionar novos resultados. Se não houver experimentos, como vamos saber se há algo que pode nos ajudar mais do que o que já temos hoje? Parafraseando o exemplo da sogra: como vamos saber se comprar uma máquina de lavar louças vai ser mais produtivo do que ficar lavando louça a louça se não a experimentarmos?

Equipe de “Jogadores”

Se os membros do seu time focam principalmente em objetivos individuais, as tecnicas ágeis baseadas em grupo provavelmente não serão uma boa opção.

Observação: Esse é um dos pontos os quais mais me decepcionaram. Esqueça metodologia, se você tem um time cheio de membros individualistas, você não tem um time! E digo mais: seu projeto será um fracasso. Um time se caracteriza por todos os seus membros terem um objetivo comum e estarem comprometidos com isso.

Uma mente aberta

As técnicas Ágeis não são convencionais e costumam ser difíceis de aprender.

Organizações ou times sem desejo em investir no aprendizado das técnicas necessárias provavelmente vão achar que o Agile é inadequado.

Observação: Definitivamente, não entendi esse ponto. Gostaria que exemplificassem uma técnica ágil de difícil aprendizado. Um dos princípios de Agilidade é simplicidade! E digo mais: acho um ponto muito negativo em companias que não têm interesse em investir na evolução dos seus colaboradores.

Invasão de privacidade

Técnicas ágeis são baseadas nos princípios de confiança e sinceridade, logo os membros do time devem aderir à transparência e estarem dispostos à abrir mão da sua privacidade.

Observação: Essa, definitivamente, não entendi. Se você, que está lendo esse artigo, é membro de um time ágil e perdeu sua privacidade por conta disso, comente esse post e conte-nos sua experiência. Por exemplo: se você se sente incomodado porque enquanto você está pareando com um colega de time você não pode parar para navegar no orkut, facebook ou twitter, sinto muito, mas lhe falta senso profissional.

“By the book”

Defensores do Agile alegam que uma dependência excessiva de metodologias pode sufocar a dinâmica e a evolução do projeto.

Se sua organização exige a adesão estrita à alguma metodologia de gestão de projeto fortemente estabelecida, então Agile não trará muitos benefícios.

Observação: Devo concordar com essa colocação e ao mesmo tempo concluír com ela que o projeto terá sua evolução e dinâmica sufocados. Contudo, técnicas de design iterativo e incremental não fariam mal algum à esse tipo de gestão, certo? J

Quais são suas prioridades?

As curtas iterações que o Agile proporciona ajudam a trazer resultados mais rapidamente – especialmente em termos de “Time to Market” e ROI. No entanto, isso requer refinamento constante do escopo do projeto.

Se os requerimentos do sistema fazem parte do contrato, então técnicas ágeis podem não ajudar muito.

Observação: Bom, algo tem grandes chances de variar. Se o “escopo” é fechado, é muito provável que custo ou tempo de projeto não serão fixos. Logo, não há problema nenhum em aderir à práticas ágeis quando seus requerimentos já estão estabelecidos, basta ter em mente essa variação de algum desses outros índices.

Vale o risco?

Agile oferece técnicas de gerenciamento de risco. Mas se a sua empresa ou cliente pedem um ambiente de projeto consistente e estável, então os métodos ágeis não devem ser seguidos.

Observação: Gostaria de entender porque, ao se aderir práticas Ágeis, o ambiente de desenvolvimento deixa de ser consistente e estável.

Concluindo tudo isso, eu vejo que minhas observações são questionamentos, pedidos de justificativas para cada uma dessas afirmações absurdas. Acho que se procurassem um pouco mais por fundamentos para cada um desses trechos, não teriam publicado tal página.

Bom, essa é minha humilde e rápida opinião. Sintam-se à vontade para comentar, criticar e questionar!

[]’s

Ricardo Serradas

O foco neste post é falar sobre a segunda parte do Agile Brazil 2010, onde os palestrantes apresentaram seus trabalhos e onde pude conhecer muita gente boa da comunidade ágil do Brasil.

O keynote de abertura foi de ninguém menos que Martin Fowler, um dos idealizadores do manifesto ágil. Sinceramente, ele não trouxe nenhuma novidade à nossa comunidade mas claro, falou com muita propriedade de assuntos de seu domínio, focando principalmente em práticas de engenharia de software voltadas ao desenvolvimento ágil. Muito bacana!

A grade de palestras ficou um pouco corrida, com muito paralelismo. Muitas vezes palestras que tinham tudo para ser de ótima qualidade rolavam ao mesmo tempo. Isso me desapontou um pouco. Mas o que vi foi muito bom! Dou um destaque especial para a palestra do Alexandre Gomes (@alegomes) e do Renato Willi (@rwilli), onde falaram sobre Desenvolvimento Ágil no Governo, onde demonstraram domínio do assunto e souberam reter a atenção do público com maestria.

E claro, com uma diversidade grande de palestras como essa, algumas deixaram sim à desejar, ou pelo conteúdo que era pouco atrativo, ou pela capacidade do palestrante de chamar a atenção do público.

Durante o evento, tive a oportunidade de conhecer pessoalmente uma galera de presença na comunidade ágil e de desenvolvimento de software, como:

André Nascimento – @alnascimento
Daniel Oliveira – @dfaoliveira
Igor Abade – @igorabade
Rafael Noronha – @rafanoronha
Rodrigo Vidal – @rodrigovidal

Entre outros. É super interessante a experiência de trocar idéias com esses caras através de grupos (como o DotNetArchitects), redes sociais (como Twitter) e depois conhecê-los pessoalmente e poder trocar idéias já como amigos de longa data! Foi um prazer conhecer vocês, pessoal!

Infelizmente, devido ao horário do meu vôo na sexta, não pude participar do keynote de encerramento que, acompanhando a hashtag do evento (#AgileBrazil), deve ter fechado com chave de ouro!

Abaixo, algumas fotos que tirei durante o evento:

Enfim, o Agile Brazil 2010 foi nota 10! Em 2011 estarei presente novamente!

[]’s

Ricardo Serradas

Post épico este! Tanto por ser o primeiro fora de São Paulo quanto por ser o primeiro que faço através de um dispositivo móvel.

Estou em Porto Alegre, Rio Grande do Sul para participar do Agile Brazil 2010. Aqui tenho tido contato com feras do mundo do Desenvolvimento de Software e de Agilidade. O evento é dividido em dois dias de cursos (terça e quarta) e dois dias de palestras (quinta e sexta) e conta com grandes nomes como Giovanni Bassi, Alexandre Magno, Michel Goldenberg, Rodrigo Yoshima, o próprio Martin Fowler, entre outros.

Os dois primeiros dias foram muito legais. Cheguei aqui na segunda e, ao sair pra jantar com alguns amigos, descobrimos no dia seguinte que na mesa ao nosso lado jantava Martin Fowler. Olha a oprtunidade de conseguir um autógrafo desperdiçada.

No dia seguinte começaram os cursos de CSM, CSPO E XP. eu participei do CSM, que acabou hoje. O curso foi bem legal e foi diferente dos cursos de CSM que já aconteceram pois, além da aula tradicional sobre o Scrum Master ministrada pelo Michel Goldenberg, algumas boas práticas de Engenharia de Software com foco no mundo ágil foram mostradas pelo Rodrigo Yoshima.

Ao final do dia, no jantar, fomos comer num lugar muito interessante: o “D’Gato” Churrasquinhos. É mole?

Abaixo, algumas fotos:

Victor Cavalcante, Giovanni Bassi e Alexandre Magno À esquerda e Rodrigo yoshima à direita, no coffee-break

Michel Goldenberg ministrando o curso de CSM

Michel novamente no curso

Bom, como estou sem computador, estou impossibilitado de fazer um post mais detalhado e de postar fotos da minha câmera também. Então, assim que estiver de posse do meu computador denovo, faço um post mais completo.

[]‘s
Ricardo Serradas

O envio de alertas por e-mail quando um evento acontece no projeto do time pode ser muito importante quando falamos de integração.

Com os Project Alerts é possível, por exemplo, enviar e-mails para o responsável pela tarefa quando ela for atribuída a ele ou quando sofre modificações; pode-se enviar uma cópia para o responsável pelo projeto quando a tarefa é finalizada, entre outros fins. Porém, o template de e-mail nativo do TFS pode não ser satisfatório para o time.

Vamos falar um pouco mais sobre os Project Alerts abaixo.

Como funciona?

No servidor de aplicação, há um agente (TFSJobAgent) que fica aguardando algum evento para disparar os alertas. Os eventos podem ser:

- Modificação em um work item;

- Um check-in é realizado;

- A qualidade de um build é modificado;

- Um build termina;

Entre outros que podem ser criados. Os templates de email (tanto texto plano quanto HTML) ficam armazenados na seguinte pasta, no servidor de aplicação do TFS:

[Drive]:\ Program Files\Microsoft Team Foundation Server 2010\Application Tier\TFSJobAgent\Transforms

Dentro dessa pasta, você encontrará dois arquivos para cada tipo de evento. O arquivo de extensão “plaintextxsl” define o template de e-mail em texto plano, enquanto o de extensão “xsl” define o formato do email HTML, além do arquivo TeamFoundation.xsl, que é como um template, uma casca (como uma Master Page) para os demais arquivos. A partir daí, cada arquivo de cada evento importa este arquivo e define as outras informações a serem exibidas.

Quando o agente identifica o evento, ele recebe uma coleção de informações contendo os campos do work item e/ou do evento para gerar uma saída com base nos arquivos mencionados acima. São elas:

- CoreFields: contém os campos e seus conteúdos, cujo namespace é System.*.

- ChangedFields: contém os campos que foram modificados neste evento.

Um fator muito importante é: campos que estão fora do namespace System.* (ou campos non-core) não são enviados nesta coleção por questões de desempenho. Portanto, se quiser, por exemplo, mostrar o campo “Start Date” (Microsoft.VSTS.Scheduling.StartDate) e ele não tiver sido modificado, não será possível recuperar essa informação no alerta.

Como customizar?

No nosso exemplo, vamos customizar o alerta de Work Item modificado no formato HTML. A modificação que faremos é simples: a linha que contém o “Assigned to:” deve ficar em negrito e removeremos a linha que contém o “Changed date:”. O que temos hoje é:

E para fazer essa modificação, vamos seguir os passos abaixo (faça back-up dos arquivos antes de começar a customização):

- Abrir o arquivo WorkItemChangedEvent.xsl em algum editor de XML ou no próprio Visual Studio;

- Dentro do arquivo, procure pelo trecho “ReferenceName[.='System.AssignedTo”. Verá que existe uma definição de uma linha de tabela (TR). Assim:

Interpretando esse trecho de código: na primeira célula da linha (PropName), ele coloca o título do campo, que é “Assigned to:”. Na segunda (PropValue), é inserido o valor.

Dentro dessa segunda TD você pode enxergar uma estrutura de repetição (foreach) e uma de validação (IF) onde ele varre os campos da coleção CoreFields em busca de um campo do tipo “System.AssignedTo”; se encontrar, exibe seu valor, através da propriedade “NewValue”.

Vamos fazer uma simples modificação de HTML. Colocaremos a tag de bold (“<b>”) nas duas tds. Fica assim:

Sobre o Changed Date, basta procurar pelo texto “System.ChangedDate” no código e remover a TR que á contém.

Depois dessas edições, salve o arquivo e faça alguma modificação em algum work item para disparar o evento. No meu caso, o resultado foi o segunte:

Daí pra frente é só ir brincando com os campos e com o template dos alertas.

[]’s

Ricardo Serradas

Muito falou-se sobre uma das features mais esperadas da versão 2010 do Visual Studio Team Foundation Server: o Gated Check-in. Neste post, vamos fazer um raio-x deste mais novo aliado na luta por uma integração contínua mais forte e código fonte de nossas aplicações de melhor qualidade.

De uma forma geral, como ele funciona?

Quando um desenvolvedor efetua um check-in, ele recebe uma notificação dizendo que suas alterações devem ser compiladas antes de serem persistidas no controle de versão. O TFS então desvia essas alterações para um shelveset. No servidor de build é feito um unshelve dessas alterações e em seguida todo o código é compilado. Se o build tiver sucesso, um novo changeset é criado a partir do shelve e o check-in é feito em nome do desenvolvedor.

Como configurá-lo?

Para que o Gated Check-in seja usado no seu time, precisamos criar uma Build Definition com essa característica. Vamos ver como funciona:

Vamos assumir que já temos configurado nosso servidor de build e que ele está definido como Build Agent e Controller no TFS.

Não vamos entrar em detalhes sobre a configuração completa de um build definition por não ser o foco principal deste post. Sendo assim, durante a configuração de uma build definition, vemos várias abas. Uma das abas que nos interessa neste momento é a de nome “Trigger”. É nela onde definimos que essa build configura o Gated Check-in:

Um passo muito importante (e que chega até ser uma “pegadinha”) no processo de configuração está na próxima aba, que é a “Workspace”. É lá que definimos para qual estrutura de pastas esta build funcionará. Veja:

Isto significa que esta política de gated check-in somada ao build automatizado só vai ser disparado se uma tentativa de check-in for realizada na estrutura de diretórios abaixo de $/TFS10Demo/dotnet/GatedCheckinDemo.

Se esta configuração não for feita da forma correta e, por exemplo, se deixarmos este campo com “$/”, esta política se aplicará para todos os projetos desta coleção. Sendo assim, um check-in em qualquer outro Team Project será barrado por este Gated Check-in e o código do projeto GatedCheckinDemo será compilado sem real necessidade.

Salvas essas e outras configurações, vamos testar se nosso Gated Check-in está funcionando. Para isso, vamos modificar algum fonte que está versionado debaixo da estrutura definida no workspace. Depois disso, vamos efetuar um check-in. Após isso, recebemos a seguinte mensagem:

*Ao clicar em Build Changes, uma nova build é disparada e as pendências de check-in na máquina do desenvolvedor são desfeitas, ficando apenas no shelveset que será usado pelo servidor de build.

Se tudo der certo, se tudo foi bem codificado e o processo de check-in foi bem feito (Get Latest Version antes, tentativa de compilação e etc), será mostrada essa mensagem na tela do desenvolvedor que efetuou o check-in:

Ela informa que o build teve sucesso e que as suas alterações foram persistidas no controle de versão. Se a opção para preservar os check-outs ficou marcada na hora de submeter o build, use o botão “Reconcilie…” para acertar seu workspace. Se não, basta apenas ignorar a mensagem e rodar um Get Latest Version para obter suas próprias alterações.

Já se o build falhar, uma janela semelhante será mostrada, sugerindo dar o unshelve das alterações que foram enviadas para que a correção possa ser feita.

* A opção “Bypass validation build and check-in my changes automatically on your behalf” é, por padrão, desabilitada para membros do grupo “Contributors”, que é o grupo onde costuma-se incluir desenvolvedores.

Você já conhecia este novo conceito? Gostou desta nova funcionalidade? Tem críticas? Comente!

[]’s

Ricardo Serradas

Desde meus primeiros contatos com o WebTest Recorder do Visual Studio Team System, identifiquei que problemas aconteciam com ele com frequência e, por conta disso, perdia tempo correndo atrás de uma solução a cada vez que isso acontecia.

E ontem aconteceu denovo. Eu, com uma instalação completa e atualizada do VS 2008 Team Suite, não conseguia ver a barra do WebTest Recorder no Internet Explorer 8. Fazendo uma pesquisa rápida, encontrei um post do Michael Taute que compila soluções para diversos tipos de problemas referentes ao plugin. Você pode ler o post na íntegra em:

http://blogs.msdn.com/mtaute/archive/2007/11/09/diagnosing-and-fixing-web-test-recorder-bar-issues.aspx

Porém, um dos problemas me chamou a atenção ontem, depois de ter passado por ele. O cenário é o seguinte:

• Windows 7 64 Bits
• Visual Studio 2008 Service Pack 1 Up-To-Date
• Internet Explorer 8

O add-on do webtest recorder estava habilitado no navegador e, mesmo assim, a barra não aparecia. Veja a solução apontada pelo Michael:

O Windows Vista faz cache da lista de barras disponíveis para o Internet explorer e a barra do gravador não estava disponível na sua lista. A correção consiste em forçar o Windows a reconstruir este cache. Para fazer isso, primeiro certifique-se que você está sem nenhuma janela do Internet Explorer aberta e então abra o editor de registros do Windows (Regedit) e exclua as seguintes chaves:

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Discardable\PostSetup\Component Categories\{00021493-0000-0000-C000-000000000046}

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Discardable\PostSetup\Component Categories\{00021494-0000-0000-C000-000000000046}

Nota: Por padrão, o editor de registro 32 bits está localizado em %WINDIR%\SysWow64\RegEdt32.exe

Vamos aguardar e torcer para que a ferramenta de testes web do Visual Studio 2010 seja mais estável

[]‘s

Ricardo Serradas

Para quem é daqueles que está sempre querendo estar um passo à frente, é uma informação muito importante. A Microsoft já disponibiliza para download um kit de aprendizado sobre o Visual Studio 2010 e o Team Foundation Server 2010. As máquinas virtuais existem nas versões para Windows Virtual PC, Microsoft Virtual PC e Hyper V.

Este material contém tudo que é preciso para estudar e entender as capacidades desta poderosa ferramenta de ALM (Application Lifecycle Management). Inclusive, a base de dados do TFS já vem populada com dados de exemplo. Há apenas uma exceção: as funcionalidades de Lab Management não estão inclusas. Ainda espera-se uma novidade vinda do time de produto relacionada a isso.

Abaixo, o link para download de cada uma das versões:

• Windows 7 Virtual PC
• Microsoft Virtual PC SP1
• Hyper V

As máquinas tem validade até 9 de abril de 2010, data de expiração do trial do SQL Server. Notificações de ativação serão exibidas durante o uso, comportamento normal de uma versão trial do Windows. Não há com o que se preocupar.

Boa diversão!

[]‘s
Ricardo Serradas