1. Você criou uma máquina virtual no VirtualBox;
2. Agora você precisa criar uma segunda VM e quer aproveitar a primeira VM como ponto de partida;
3. Para isso, copia o VHD/VDI/VMDX e tenta adicioná-lo à nova máquina virtual.

É quando você se depara com a mensagem de erro na janela ao lado!

Isso acontece porque o VirtualBox cria um identificador único (UUID) para cada disco virtual que você vier a utilizar. Como esse UUID é gravado dentro do próprio disco, ao adicionar uma cópia de um disco pré-existente ele detecta a duplicata.

O “truque” é gravar um novo UUID na cópia. Abra o prompt de comando e execute o comando abaixo (o arquivo VBoxManage.exe está no diretorio de instalação do VirtualBox):

VBoxManage internalcommands sethduuid X:\diretório\MeuVHD.vhd

Um abraço,
    Igor

Desenvolvimento Ágil de Aplicações com SCRUM e Team Foundation Server “11”

Empresas no mundo inteiro têm cada vez mais dificuldade para desenvolver e entregar software de qualidade. Os desafios são vários, tais como gerenciar as expectativas do usuário e as mudanças constantes de requisitos, bem como garantir a coesão e o foco do time. Venha ver como o desenvolvimento ágil de aplicações, apoiado sobre o SCRUM e o novo Team Foundation Server “11”, podem ajudar times de desenvolvimento a melhorar seu dia-a-dia de trabalho para entregar software de qualidade a seus clientes.

A palestra em Sorocaba será no próximo sábado, dia 19/05/2012.

Já em Barra Bonita será no sábado seguinte, dia 26/05/2012.

Espero ver todos lá!

Em vez de deixar um comentário no blog do Elemar achei melhor colocar o comentário aqui e depois eu volto lá e linko pro comentário, e vocês ganham poder ler a discussão toda. Aproveitem e já leiam o resto do blog também que é muito bom. Vamos lá.

É difícil classificar testes de unidade ou integrado ou aceitação como importante ou menos importante. Depende de qual ponto de vista você observa. É isso que tenho visto que leva alguns a defender um ou outro como mais importante. Basta observar o post e os comentário pra perceber isso.

Por esse motivo, temos que entender exatamente do que estamos falando.

Do ponto de vista de que um teste é responsável por me dizer quando um sistema quebra: tanto testes de unidade quanto de integração são capazes de dizer isso, mas de fato, assim como aponta o Juan, os de integração dificilmente vão apontar exatamente o local. Os de unidade são muito mais precisos do que os de integração nesse sentido. Por outro lado, se um teste de unidade quebrar, um de integração também deveria quebrar. Dessa forma, tenho uma informação mais genérica, mas que aponta na direção do negócio, e tenho uma informação mais precisa, que aponta na direção técnica. Qual a mais importante? Depende da sua necessidade. Eu diria que as duas são importantes e depende do que você está fazendo. Não diria que dá pra prescindir de nenhuma das duas.

Mas há uma diferença aí: não necessariamente quando um teste de integração quebrar, um teste de unidade irá quebrar também. O problema pode ser justamente na integração, enquanto as unidades funcionam bem, há um erro em como elas se inter-relacionam. Isso torna os testes de integração mais efetivos pra pegar erros, por serem mais abrangentes: testam as unidades, mas também como se integram.

Do ponto de vista da facilidade de escrita e produtividade de escrita: lógicamente testes de unidade são melhores nesse ponto de vista. A questão é: essa característica é mais importante do que as outras? Difícil dizer isso. É verdade que se você focar em escrever testes de ponta a ponta não vai ter tempo de fazer testes de unidade? Não, não é verdade, dado o uso correto das ferramentas disponsíveis esses testes serão mais lentos para serem escritos, mas não vão tomar todo o seu tempo. Por outro lado, o código usado em testes integrados com frequencia pode ser utilizado também para o caso real, servindo de inspiração para a escrita das camadas mais externas.

Quanto ao estilo de trabalhar usando BDD ou ATDD, com outside-in. Eu sei do benefício de trabalhar dessa forma, essa é a forma com que eu trabalho, e praticamente toda a equipe da Lambda3 trabalha. Nós criamos testes de aceitação automatizados utilizando técnicas como o BDD. Esse tipo de teste, que na verdade é uma especificação executável, é importante porque ajuda a guiar o comportamento do software. Nem encaro esse tipo de artefato como um teste, ao menos enquanto está sendo usado para descrever um comportamento. Depois, ok, trata-se de um teste de regressão. Mas esse é simplemente um efeito colateral positivo, não é o motivo que me faz trabalhar com BDD. Se o objetivo fosse ter testes de regressão eu poderia escrever testes depois, e eles não guiariam o comportamento.

Nem toda especificação executável escrita ao estilo de BDD será um teste integrado, mas em geral é muito mais comum que os testes escritos com BDD sejam testes integrados que podem ser encarados como testes de aceitação. Essa é a ideia por trás do outside-in, criar uma descrição de como o software se comporta, em termos de negócio, e dificlmente você faz isso com testes de unidade.

Com relação à fragilidade de testes integrados, isso é fato, testes que vão de uma ponta a outra do sistema com frequencia quebram por motivos alheios ao comportamento do sistema. Isso obviamente é um problema, que, é importante dizer, pode ser mitigado e diminuido ao ponto em que não chega a ser um problema, na grande maioria dos casos. E isso não quer dizer que testes de unidade são mais importantes, só que são mais resistentes.

…

Assim,  gostaria que, em vez de falarmos de importância, falemos de relevância dentro de um contexto. Alguns cenários serão melhores com testes de unidade, outros com testes integrados. Abrir mão de um martelo, só porque você tem uma excelente chave de fenda, me parece um pouco míope. Ambas as ferramentas são igualmente importantes quando necessárias.

Uma estratégia bastante interessante seria usar o mesmo servidor SMTP já configurado para o TFS – dessa forma você não precisa manter essa configuração em seu plugin.

Essa configuração – e muitas outras – está gravada no TFS Registry. Para acessá-la, use o exemplo de código abaixo (cortesia do MVP português Tiago Pascoal):

internal class EmailSettings
{
    private TfsTeamProjectCollection _tfs;
    private string smtpServer, fromAddress;
    private Nullable emailEnabled;

    public EmailSettings(TfsTeamProjectCollection tfs)
    {
        tfs = tfs;
    }

    public string GetSMTPServer()
    {
        if (smtpServer != null) return smtpServer;

        return smtpServer = GetValueFromRegistry("/Service/Integration/Settings/SmtpServer");
    }

    public string GetFromAddress()
    {
        if (fromAddress != null) return fromAddress;

        return fromAddress = GetValueFromRegistry("/Service/Integration/Settings/EmailNotificationFromAddress");

    }

    public bool GetEmailEnabled()
    {
        if (emailEnabled.HasValue) return emailEnabled.Value;

        emailEnabled = GetValueFromRegistry("/Service/Integration/Settings/EmailEnabled");

        return emailEnabled.Value;
    }

    private T GetValueFromRegistry(string key)
    {
        ITeamFoundationRegistry service = tfs.ConfigurationServer.GetService();

        return service.GetValue(key);
    }
}

Um abraço,

Vamos lá, começando pelo básico. Para quem não pode copiar a máquina no dia do hands on ou quer uma versão digital do material dado, segue o link onde podem ser encontrados :

• Laboratórios e Máquina Virutal do Visual Studio ALM 2010
• Laboratórios e Máquina Virtual do Visual Studio VNext

Perfil  – Time de Desenvolvedores e Arquitetos:

• Lab 1 – Introdução ao Source Control:
• http://msdn.microsoft.com/pt-br/library/ms181368.aspx – Link sobre source control no MSDN
• http://social.msdn.microsoft.com/Forums/is/tfsversioncontrol/thread/85602e42-9c99-424c-9ed9-cebe883a847b – Thread no MSDN falando de como conectar versões antigas no TFS 2010.
• Lab 2 – Branch e Merge com Team Foundation Server 2010
• Visual Studio Team Foundation Server Branching and Merging Guide – Esse é um guide escrito pelos Visual Studio ALM Rangers sobre algumas estratégias de Branch e Merge para as versões 2010 e já está disponível a versão beta do Vnext.
• Lab 3 – Customização de Workflow de Build
• Team Foundation Build Customization Guide – Mais um guide dos Visual Studio ALM Rangers só sobre Team Build e como trabalhar com algumas customizações.
• Lab 4 – Depurando código com Intellitrace
• Videos no Channel 9 sobre Intellitrace
• Lab 5 – Utilizando Code Analysis para Melhoria da Qualidade de Código
• Video Channel 9
• Lab 6 – Code Discovery utilizando Architecture Tools
• Doug Seven- Code Understanding and Systems Design with Visual Studio 2010
• Entendendo Sistemas Existentes com Visual Studio 2010
• Visual Studio Architecture Tooling Guide
• Lab 7 – Entendendo Acoplamento de Classes
• Entendendo Sistemas Existentes com Visual Studio 2010
• Visual Studio Architecture Tooling Guide
• Lab 8 – Utilizando o Architecture Explorer
• Video Channel 9
• Visual Studio Architecture Tooling Guide

Perfil – Líderes e Coordenadores :

• Lab 1 –Planejando Seus projetos com o TFS 2010
• Planejando e acompanhando projetos
• Proactive Project Management with Visual Studio 2010
• Agile Planning Templates in Visual Studio Team System 2010
• Lab 2 – Acompanhamento da Qualidade
• Acompanhamento de Bugs, tarefas e outros itens de trabalho
• Lab 3 – Utilizando Excel e Report Builder para Relatorios Customizados
• Customização de relatórios no TFS 2010
• Criação, personalização e gerenciamento de relatórios para ALM de Visual Studio

Perfil – Time de Qualidade e Testadores :

Links para o MSDN : Testando o aplicativo

Links que abordam o modelo completo :

• Tudo o que você precisa saber sobre testes no Visual Studio – Parte 1
• Tudo o que você precisa saber sobre testes no Visual Studio – Parte 2
• Tudo o que você precisa saber sobre testes no Visual Studio – Parte 3
• Lab 1 -Planejamento de Testes com o Microsoft Test Manager 2010
• Introdução e visão geral sobre testes e qualidade na Plataforma Microsoft
• Planejamento de testes com Test Manager 2010
• Derrubando as barreiras entre testadores e desenvolvedores
• Lab 2 -Gerenciamento de Casos de Testes com o Microsoft Test Manager 2010
• Gerenciando grandes volumes de teste em uma mesma solução
• Tudo o que você precisa saber sobre testes no Visual Studio – Parte 3
• Lab 3 -Criando e Executando Testes Manuais com o Microsoft Test Manager 2010
• Entendendo os testes manuais
• Tudo o que você precisa saber sobre testes no Visual Studio – Parte 3
• Lab 4 -Testes Exploratórios com o Microsoft Test Manager 2010
• Visual Studio Team System 2010: Exploratory Testing
• Exploratory Testing 
• Lab 5 -Testes em Diferentes Plataformas com o Microsoft Test Manager 2010
• Tudo o que você precisa saber sobre testes no Visual Studio – Parte 3
• Lab 6 -Introdução a Coded UI com o Microsoft Visual Studio Ultimate 2010
• Iniciando o uso dos testes de IU codificados
• Building Robust, Maintainable Coded UI Tests with Visual Studio 2010
• Lab 7 -Ciclo de Correção de Bugs com o Microsoft Test Manager 2010
• Tudo o que você precisa saber sobre testes no Visual Studio – Parte 3

Tive o imenso prazer e satisfação de ser um dos palestrantes. Minha apresentação mostrou como podemos gerar os relatórios em diferentes ferramentas (Excel e Report Builder por exemplo). Apresentei também relatórios para um melhor de controle dos merges entre as branchs complementando todo o conceito apresentado pelo Claudio Leite ALM Summit 2012 – Branch.

A minha apresentação está disponibilizada no link abaixo.

ALM Summit 2010 – Reports

Agradecemos a presença de todos e esperamos ter contribuido no aprendizado do TFS 2010.

Abraços,

Vinicius Moura.

Primeiro é onde vocês podem baixar  o Branch Guide dos ALM Rangers.

Nesse link ( Projetos dos ALM Rangers ), você pode encontrar todos os projetos que estão sendo desenvolvidos pela equipe, vale a pena dar uma olhada em tudo que estamos trabalhando e qualquer proposta nova ou problema encontrado não deixe de nos comunicar!

Mas especificamente sobre a minha palestra, segue o endereço do Visual Studio Team Foundation Server Branching and Merging Guide .

Outros pontos que não deram tempo de passar na palestra:

Melhores Práticas

• Usar nomes significativos para o Branch – Sempre que possível utilize nomes que realmente tenham algum siginifcado para o seu projeto. Isso parece um detalhe bobo, mas imagine a situação onde você está utilizando a estratégia por feature, e começa utilizando nomes não tão significantes. Com o andar do projeto, esse número de branches pode ficar alto e sem nomes significativos, pode começar a gerar problemas para a sua equipe, impossibilitando que ela saiba qual feature eles tem que trabalhar no momento.

• Sempre prefira Branch ao invés de code-freezen – Code-freezen é um dos ” porquês “ que queremos evitar. Então sempre que surgir uma situação onde a sua equipe de desenvolvimento tiver que ficar parada para que testes, deploys ou qualquer outra coisa que não seja desenvolver novos códigos, acertar bugs identificados em versões anteriores, pense em criar um branch. Isso já gera um valor para esse branch justificando a sua criação.

• Integre sempre que possível – Integrar sempre que possível tem que ser um mantra! deixar para fazer tudo na última hora, trazer as modificações geradas na main para o seu branch de trabalho apenas no final, pode gerar um tempo muito maior de resolução de conflitos e com isso impactar diretamente no seu prazo de entrega. Por isso, integre sempre, pelo menos 1 vez por semana, mais do que isso, você e sua equipe já estarão correndo riscos.

• Resolva conflitos no “Soft” branch – O Soft branch é onde você está desenvolvendo no momento, é o seu branch de desenvolvimento. Sempre resolva os comflitos nesse branch e nunca no que é considerado o mais estável, como o Main por exemplo. Isso que dizer que você antes de publicar alguma nova feature para a Main, baixa a versão do Main para a seu Branch de desenvolvimento resolva todos os conflitos e aí sim, faça a entrega para o Main.

• Evitar branches em cascatas – Tente evitar ao máximo o cascateamento nos branches, pois isso torna muito mais complicada a sua integração e trás um tempo muito maior para a liberação do seu código. Como vimos no início da palestra, isso vai impactar diretamente no custo de manutenção do branch, o que pode não trazer o valor esperado para o branch exigindo que a sua estratégia tenha que ser completamente revista.

• Isole a mudança – Isolar a mudança e não a equipe. Nós temos que isolar apenas  o que queremos modificar no nosso sistema sem impactar os outros membros do time e nunca isolar um grupo ou uma pessoa. Todos tem que saber o que está acontecendo no sistema e porque algum branch foi criado. Caso você comece a isolar as pessoas, você começará a criar silos na sua equipe o que trará muitos problemas para o seu projeto. TOME MUITO CUIDADO!

• Evitar Baseless Merge  – Como vimos, as vezes o Baseless Merge é necessário (Estratégia de Branch por Release com Mainline), mas tome cuidado com essa técnica, pois ela acaba abrindo caminhos novos caminhos para a release do seu sistema que podem forçar o seu código a não passar por áreas críticas e ser lançada uma versão sem todas as funcionalidades ou bugs que já foram corrigidos.

Anti-Padrões

• Merge Paranoia – Medo de realizar o merge entre dois branches. Se isso está acontecendo com o seu projeto, com certeza sua estratégia de branch não é a mais adequada para o seu problema. Pare agora e revise sua estratégia. Esse medo de realizar merges entre branches não pode existir.

• Merge Mania – Ao contrário da primeira, realizar merge todo o tempo também não é uma coisa boa. Esse item também sugere que a estratégia selecionada não está sendo a mais eficaz nesse momento para o seu projeto. Para um tempo e revise o seu modelo.

• Big Bang Merge – Deixar para fazer o merge apenas na última hora, na hora de realizar a liberação do código para Release. NUNCA FAÇA ISSO!

• Branch Mania – Um dos pontos para que um branch seja criado é descobrir qual o valor que ele trará para o projeto. Se ele não trouxer valor ou tiver alguma outra técnica que possa ser empregada no lugar, então não crie o branch! Cada branch que você criar, é mais uma complexidade que você está trazendo para a gestão do seu sistema. Por tanto, sair criando branches sem um bom motivo também é um problema.

• Branches Temporarios – Nunca crie branches para executar algum teste ou fazer pequenas alterações temporárias! Isso não trás valor para o seu projeto! para realizar esse tipo de tarefa, prefira usar shelve, com certeza ele vai resolver o seu problema e não trará complexidade desnecessária para o seu gerenciamento.

Escolhendo a sua estratégia

Esse não é um modelo único, porém é um ponto de partida para que você escolha qual estratégia de branch deve ser utilizada no seu projeto.

Utilize isso como um ponto de partida, mas adicione mais alguns pontos de validação para a sua decisão. Uma delas é, qual caminho que eu teria que percorrer para fazer a liberação do meu código ? Existe alguma compliance que eu devo seguir na minha empresa ? As vezes, como vimos na DEMO, teremos que utilizar mais de uma estratégia para atingir os objetivos que aquele projeto necessita.

Tenha em mente que cada projeto pode ter uma estratégia de branch diferente. Então sugiro que você tenha pelo menos 3 modelos padrões na sua empresa para projetos pequenos, projetos médios e um para projetos grandes ou críticos. Mas na hora de definir, faça uma simulação para validar se aquela estratégia não vai lhe trazer complexidade desnecessária.

Espero que tenham gostado da palestra e em caso de dúvidas, deixem seus comentários ou enviem por twitter ou e-mail.

Até a próxima!

Minha participação foi mostrar como criar Políticas de Check-in e Geradores de Dados personalizados.

Baixe agora a apresentação. O código-fonte vai ser postado na sequência; atualizo o post com o link para download do código dos exemplos.

Mais uma vez, obrigado a todos que vieram ao ALM Summit Brasil!

Um abraço,
    Igor

Foi muito legal falar mais uma vez sobre uma das ferramentas mais bacanas – e mais desconhecidas – do Visual Studio: os projetos de bancos de dados, que foram introduzidos com o VSTS for Database Professionals.

Como combinado, a apresentação que usei na palestra já está disponível para download:

Espero que todos tenham curtido a palestra. E para quem não teve oportunidade de participar, fique ligado na Lambda3 TV – logo teremos vídeos sobre o “DataDude” e o novo SQL Server Data Tools!

Um abraço,
    Igor

Bom, mas antes disso: Você sabia que há mais de uma CLR? Aliás, o que é CLR mesmo?

Common Language Runtime é a parte do .NET Framework onde seu código é executado. Os diversos serviços essenciais para uma aplicação .NET, tais como o compilador JIT e os gerenciadores de código e memória, são parte da CLR. Mal comparando, a CLR equivale à máquina virtual (JVM) do Java.

Originalmente a Microsoft criou uma única máquina virtual / CLR, que vem evoluindo desde o .NET 1.0. Essa CLR presente no .NET é a versão de referência, baseada na especificação ECMA/ISO da Common Language Infrastructure.

Entretanto, quando surgiu a necessidade de rodar código .NET em outros ambientes – tais como num smartphone ou mesmo num browser – percebeu-se que a enorme quantidade de recursos da CLR havia, de certa forma, se tornado um problema. A CLR era maior do que seria possível hospedar nesses ambientes restritos. Foi aí que começaram a surgir novas CLRs:

• Silverlight (browser);
• Silverlight (Windows Phone 7);
• .NET Compact Framework;
• .NET Micro Framework;
• Xbox etc.

Todas essas CLRs têm pontos em comum, o que significa que era possível escrever código “compartilhável” – ou seja, um mesmo código-fonte podia ser reaproveitado em diferentes projetos (exemplo comum: WPF, Silverlight Browser e Silverlight WP7). Ou seja, havia a compatibilidade de código, mas não a compatibilidade binária para que assemblies produzidos pelo Visual Studio pudessem ser diretamente referenciados por diferentes plataformas.

É aqui que voltamos ao assunto deste post. Com as Portable Class Libraries é possível criar assemblies que podem ser diretamente compartilhados entre diferentes plataformas/CLRs. Finalmente a tão conveniente compatibilidade binária!

O que muda?

Quando você usa Portable Class Libraries, o Visual Studio garante que o código que você está escrevendo – e o binário resultante – serão compatíveis com todas as plataformas que você selecionar. A consequência natural disso é que você sempre estará nivelando pela plataforma com menos recursos.

Todos os outros benefícios oferecidos pelo Visual Studio – testes de unidade, Intellisense, Intellitrace e outros – continuam funcionando exatamente da mesma forma com que estamos acostumados.

Como usar?

Portable Class Library é um novo modelo de projeto disponível no Visual Studio “11”. Basta usar esse novo modelo de projeto no lugar do antigo Class Library:

Se você ainda estiver usando o Visual Studio 2010, pode baixar o modelo de projeto a partir da Visual Studio Gallery:

Depois disso é só criar seu projeto no Visual Studio 2010!

Um abraço,
    Igor

Para saber mais:

• Portable Class Libraries (VS2010): http://msdn.microsoft.com/en-us/library/gg597391.aspx
• Portable Class Libraries (VS11): http://msdn.microsoft.com/en-us/library/gg597391(v=vs.110).aspx
• API Differences in Portable Class Library: http://technet.microsoft.com/en-us/query/gg597392

A Lambda3 acaba de se confirmar como uma das patrocinadoras do .NET Architects Days 2012, que acontecerá dias 1 e 2 de Junho em São Paulo. Discutimos internamente e apoiar um evento que tem tanta ligação conosco e uma comunidade igualmente próxima faz todo o sentido, e daí o patrocínio.

O .NET Architects nasceu de um post neste blog (quando ainda era o .NET Unplugged), e começou a tomar corpo quando o Victor Cavalcante conversou comigo no TechEd uns anos atrás. Hoje, estamos os 2 organizando o evento, e também palestraremos. É muito importante para nós dois estar lá.

Ainda não sabemos exatamente o que faremos com o nosso espaço no evento. Teremos 9 metros quadrados pra puxar uma interação interessante com a comunidade. Entre as ideias estão dojos, open spaces, ou coisas do tipo. Ainda vamos definir.

Vemos vocês lá.

Se você não conhecia o XKCD, faça duas coisas: primeiro, volte no post e pare o mouse sobre a imagem e leia o texto alternativo. Oi leia aqui, ele diz isso:

“Umwelt is the idea that because their senses pick up on different things, different animals in the same ecosystem actually live in very different worlds. Everything about you shapes the world you inhabit–from your ideology to your glasses prescription to your web browser”

Ou em português:

“Umwelt é a idéia de que porque seus sentidos notam coisas diferentes, animais diferentes no mesmo ecossistema na verdade vivem em mundos muito diferentes. Todas suas características moldam o mundo em que você habita – da sua ideologia, passando por sua receita de óculos ao seu navegador”

Toda tirinha do XKCD só termina quando você lê o alt text.

Segundo: volte ao XKCD e assine o RSS ou anote nos seus favoritos. É a melhor tira geek da atualidade, muito a frente do segundo lugar.

Mas não era isso que eu queria falar. O que eu queria falar é sobre umwelt, ou a ideia de que suas características e opções decorrentes de quem você é mudam o mundo em que você vive. Voltávamos, agora a pouco, Victor Hugo Germano e eu da nossa sessão de escalada. Vínhamos de bicicleta e era a primeira vez que fazíamos isso. Tínhamos já ido da Lambda3, que fica na Frei Caneca com a Paulista, até a academia 90 Graus, que fica atrás do Aeroporto de Congonhas e agora voltávamos. Foram 12 kms e vocês podem ver o trecho no Runkeeper. O Victor, que já morou em Floripa, Irlanda e outros lugares, comentou comigo que se sente muito feliz de poder escalar e pedalar, e que isso torna a vida dele completamente diferente do que seria se ele não estivesse fazendo isso. Eu acrescentei que minha vida estava também muito diferente nos últimos anos, com esse lance todo de deixar de ser sedentário, agora escalando, pedalando, e com a Lambda3 e tudo o que tem acontecido.

Foi então que me lembrei da tirinha do XKCD. Essa tira é especial. Ela é diferente em diversos lugares do mundo, em cada canto aparece uma tira diferente. Se você abrir ela com outros navegadores vai ver tiras diferentes. Se abrir com tamanhos de janela diferentes, pode ser que a tira altere. Se mora em outro continente, é outra tira completamente diferente, algumas muito específicas para o país em que a pessoa está vendo a tira (vejam as diversas tirar catalogadas por diversos contribuidores aqui). Ao lembrar da tira, notei que minha vida seria de fato muito diferente se eu não tivesse arriscado e seguido como consultor independente, porque não teria tido tempo pra me dedicar e me tornar um profissional melhor, e me envolver mais com a comunidade. O que depois levaria à abertura da Lambda3. E à vida que tenho hoje. Uma coisa puxa a outra. É interessante como pequenas mudanças na direção correta podem fazer toda a diferença, e é igualmente interessante como é difícil ter certeza se a direção é correta. E por isso temos que nos adaptar e corrigir quando erramos.

Da mesma forma como diz o texto, duas pessoas que trabalhem uma do lado da outra, ou no mesmo prédio mas em andares diferentes, ou vizinhas uma da outra, podem viver vidas completamente diferentes, quase opostas.

Isso joga sobre nós um senso de responsabilidade sobre nossa felicidade, nosso status atual e nosso status futuro. Sou eu que me coloco no mundo em que vivo, eu sou o principal responsável sobre como o vejo e para onde ele vai. E posso mudar tudo para ir para outro lado se não estou satisfeito. Eu, especificamente, posso dizer isso, porque eu já fiz isso. E trabalho ensinando empresas e pessoas a fazerem isso, e já vi isso acontecer diversas vezes. Estou inclusive envolvido em projetos de mudança atualmente.

Talvez isso explique porque vejo tanto criticismo e descrença. Vejo muita gente falando que democracia organizacional nunca funcionaria, que agilidade é uma utopia, que orientação a objetos é coisa acadêmica. Eu acredito que no mundo em que essas pessoas vivem isso é tudo verdade. Só que no meu não é. No meu mundo, democracia organizacional e agilidade me tornam melhor que meu concorrente que não segue nos mesmos princípios. No meu mundo, OO é realidade e ajuda a modelar sistemas complexos de verdade.

Fico feliz de muitas vezes ajudar a ampliar a visão de mundo de quem posso. Esse blog, os podcasts, eventos, e toda minha ação na comunidade, são formas de fazer isso. Espero que estejam ajudando.

Agora é sobre a configuração da Host Key. Gosto de usar a tecla “Right Alt” (também conhecida como “Alt Gr”) já que, além de estar à mão ela também não serve para nada . Essa configuração, aliás, é a padrão do VirtualPC (que usei por muito tempo) e talvez por isso tenha sobrado alguma memória muscular.

Teoricamente isso seria algo muito simples de resolver: Na tela inicial no VirtualBox bastaria ir em File | Preferences | Input, clicar na caixa de texto Host Key e então pressionar a tecla Alt da direita. Mas este é o resultado:

Se não dá para configurar do jeito fácil, vamos ao jeito difícil!

AVISO: Execute o comando abaixo por sua conta e risco! Não me responsabilizo por quaisquer problemas que isso possa causar no seu computador, nas suas máquinas virtuais ou até mesmo no seu forno de microondas, na sua tevê ou na sua samambaia!

Abra um prompt elevado, vá ao diretório de instalação do VirtualBox (que por padrão é %PROGRAMFILES%\Oracle\VirtualBox) e execute o comando:

VBoxManage setextradata global GUI/Input/HostKeyCombination 65514

Onde 65514 é o código Python para RightAlt, de acordo com http://packages.python.org/pyglet/api/pyglet.window.key-module.html.

Para saber mais, veja https://forums.virtualbox.org/viewtopic.php?f=1&t=46523.

Um abraço,
    Igor

• Microsoft Test Manager
  • Criação e configuração de planos de teste
  • Criação de test suites a partir de user stories
  • Criação de casos de teste
  • Execução de casos de testes com o test runner
  • Criação de casos de teste com diferentes configurações de browser
  • Execução de Casos de Testes utilizando FireFox
  • Geração de bugs a partir do test runner
  • Anexo automático de evidências como vídeos, screenshots, Intellitrace, event log e system information nos bugs.
  • Gerenciamento de bugs e casos de testes
  • Identificação e verificação de bugs corrigidos
  • Identificação e re-teste de casos de testes impactados
  • Criação de casos de teste com fonte de dados (parâmetros)
  • Databind de casos de teste com a aplicação
  • Execução de casos de testes com parâmetros diferentes
• Coded UI
  • Geração de teste automatizado a partir de um caso de teste do Test Manager
  • Inclusão de assertions
  • Geração de código de teste do zero
  • Execução de um caso de teste complexo (cenário de compra de produto)
• Build (apenas utilização)
  • Integração Contínua
  • Deployment automático no IIS

Se você perdeu os últimos dois episódios, não deixe de acessá-los:

• Tudo o que você precisa saber sobre testes no Visual Studio – Parte 2
• Tudo o que você precisa saber sobre testes no Visual Studio – Parte 1

Abraços e até a próxima
André Dias

A pergunta foi: “Quais são as vantagens de fazer a build no Team Build em vez do Visual Studio?”. Bom, vamos à resposta:

1. Independência de pessoas e de estações de desenvolvimento
   • Qualquer pessoa com permissão pode gerar a build com apenas um click. Você não fica dependendo de apenas uma pessoa que já tem a máquina configurada para gerar a build;
2. Melhora o gerenciamento de dependências
   • É muito comum o código compilar na máquina do desenvolvedor, mas quando vai para o servidor de build, não funciona de jeito nenhum. Isso normalmente ocorre devido a um gerenciamento de dependências ruim;
     
   • Como o servidor de build é uma máquina independente e ele compila o código que está no source control, se a sua estratégia de versionamento não gerenciar as dependências corretamente, o servidor de build dificilmente conseguirá compilar a sua aplicação, ou seja, ele te forçará a trabalhar direito;
     
   • Outro ganho que você terá aqui, é que sempre que um programador novo entrar no seu time, a chance dele fazer um get latest version no projeto e compilar de primeira será altíssima;
3. Integração Contínua
   • A cada check-in você poderá:
     1. Executar testes de automatizados (inclusive de UI) garantindo que as funcionalidades existentes não sejam quebradas (teste de regressão);
     2. Ligar o Code Coverage e saber o percentual de código que os testes estão cobrindo;
     3. Validar a arquitetura da sua aplicação e garantir, por exemplo, que a camada de apresentação não faça acesso direto ao banco de dados;
     4. Execução de análise de código estática;
4. Relatórios
   • Diversos relatórios cruzando informações sobre qualidade, build e bugs são gerados automaticamente pelo simples fato de você utilizar o Team Build;
5. Políticas de check-in
   • Você pode impedir que o programador envie um código para o controlador de versão caso a build esteja quebrada. Isso evita que uma build ruim, fique ainda pior;
6. Notificação por e-mail
   • Seu time pode ser avisado toda vez que uma build for executada, falhar ou mesmo ser promovida para ambientes de homologação / produção;
7. Agendamento de Builds
   • Com esse recurso, você pode usar a prática de build noturna e, com isso, quando o programador chegar para trabalhar pela manhã, já saberá se a build está estável ou se tem algo para corrigir do dia anterior;
8. Gated Check-in
   • Recurso muito bacana que permite rejeitar o check-in do programador caso a build falhe, seja por problemas de compilação, testes, arquitetura ou qualquer outro motivo.
9. Automação de Deployment
   • Você pode estender o Team Build para usar frameworks como o MSBuild e MSDeploy para implantar o seu site em homologação/produção e atualizar o seu banco de dados com apenas um click;
10. Rastreabilidade
    • Toda vez que você gera uma build, o Team Build automaticamente identifica e associa as changesets, work items e outros artefatos com a build. Com isso, você consegue ter uma rastreabilidade entre requisitos, código fonte, build e resultados de testes e consequentemente passa a atender práticas de Gerenciamento de Configuração requeridas pelo CMMi,  MPS.br e ITIL;
11. Integração com o Microsoft Test Manager
    • Se você utilizar o MTM, o seu tester, assim que identificar que uma nova build foi gerada, saberá quais BUGs ele precisa verificar e quais planos de testes foram afetados e precisam ser retestados;
12. Gerenciamento de Builds
    • A partir  de um console de gerenciamento, você consegue saber quais builds estão em ambientes de homologação, produção, etc;
13. Aplicação de label automática;
    • Você não precisa se preocupar em aplicar labels no seu código fonte. O team build já faz isso para você e caso você queira alterar um código que está em produção, basta criar uma branch da label que o Team Build gerou;
14. Totalmente extensível
    • Se nada disso acima te atender, você pode ir além e estender o workflow, eventos, e tudo mais que você imaginar;

E aí? Depois de tudo isso, você ainda vai fazer “build” no F5?

Abraços
André Dias

Em 2 meses estaremos mais uma vez no DNAD. O .NET Architects Days é o maior evento com foco exclusivo em arquitetura e .NET do Brasil, e está também entre os maiores eventos de .NET do país.

Já é a quarta edição do evento, que é o encontro anual do .NET Architects. Começamos pequenos e crescemos todo ano. Agora estacionamos em 350 pessoas, principalmente porque encontramos um local muito bom, que tem esse limite de tamanho, e qualquer evento maior demandaria de nós um esforço muito grande. Também exigiria da organização um comprometimento financeiro que nos deixa um pouco desconfortáveis.

Esse ano o evento terá, novamente, 2 dias. Será dias 1 e 2 de Junho, sexta e sábado, no mesmo hotel Braston que nos recebeu ano passado. O hotel é muito bem localizado, ao lado do metrô e no centro de São Paulo.

A grade de palestras está quase fechada e com excelentes palestrantes e vai falar de ESB, REST, novos paradigmas para web, nodeJS, e lógico, Cloud. Teremos ainda espaços para Lightning Talks e Open Spaces.

Daqui da Lambda3 vamos palestrar Victor Cavalcante e eu, sobre a nova web (você pode conferir um pouco da ideia no último episódio do Tecnoretórica). A Lambda3 também apoia o evento administrativamente, assim como ano passado, gerenciando toda a parte financeira e administrativa.

No Twitter, você pode acompanhar o evento pela hashtag #dnad12 e pelos posts do @netarchitects. Estamos também com uma página no Facebook, onde você pode discutir sobre o evento e dizer se vai. E se você divulgar o evento, ganha um link de volta, sendo uma das nossas páginas amigas.

Vai ser uma ótima oportunidade pra reencontrar a comunidade e fazer um network bacana. E pra quem quiser ver como foi o evento nos anos anteriores, vejam aqui meus posts sobre 2009, 2010 e 2011, além dos sites de cada ano que ainda estão no ar.

Vejo vocês por lá!

Essas mesmas empresas também utilizam serviços internos como o Team Foundation Server para gerenciar seus projetos de desenvolvimento, independente da linguagem .NET, Java, Cobol, VB6 etc.

Nesse cenário surge a necessidade de integração entre alguns serviços internos com serviços externos. E como podemos fazer isso com o Team Foundation Server e o Gmail ?

Nativamente, não é possível passar informações de servidores e-mail, usuários e contas para autenticação, por isso temos que implementar uma funcionalidade do IIS, o SMTP Server, para criar um servidor virtual de SMTP e fazer ele “conversar” com o gmail, permitindo que o TFS envie seus alertas.

Para fazer isso, primeiro precisaremos instalar a feature do SMTP Server, para isso acesse o Server Manager, e selecione a feature do SMTP Server

Click em Next até chegar ao final da instalação. Depois de instalar, precisamos configurar o SMTP Server do IIS para isso, vamos acessar o IIS Manager abrir a Feature do SMTP E-mail

Na tela de configuração da Feature do SMTP E-Mail, deixaremos as opções padrões.

Agora precisamos configurar o nosso servidor virtual para conversar com o Gmail. Para isso, vamos acessar o IIS Manager 6.0

Ao abrirmos a console do IIS Manager 6.0, percebemos que o serviço está parado, então o primeiro passo é iniciar o serviço. Selecione o serviço ao lado direito e depois clique no botão iniciar (a figura igual ao botão play na barra superior)

Depois de iniciado, selecione o serviço e entre nas propriedades para começarmos as configurações

Na aba Access, vamos habilitar quais as máquinas vamos permitir que faça relay nesse servidor. Podem ser adicionadas máquina a máquina, uma rede válida ou um domínimo específico. No nosso exemplo, vou adicionar uma rede.

Agora na aba Delivery, acesse a opção Outbound Sercurity selecione a opção basic authentication e coloque o e-mail do gmail e a senha de acesso do e-mail. Tem que ser um e-mail válido. São com essas informações que o IIS realizará a conexão com o Gmail para enviar os e-mails de alerta. Importante não podemos esquecer de marcar a opção TLS Encryptation

No Outbound Connections precisamos alterar a porta de comunicação de TCP. Por padrão a porta é a 25, porém o gmail utiliza a porta 587

Por último, vamos na opção Advanced. Nessa tela vamos informar qual é o nome do nosso servidor virtual, tem que ser o nome do seu servidor que é conhecido na rede (nome + domínio)  e o smart host, precisamos informar qual é o smtp do gmail (smtp.gmail.com), conforme figura abaixo

Com isso, configuramos o Servidor de SMTP, agora vamos configurar os alertas do Visual Studio. Para isso, entre na console administration, selecione o application tier e role até a opção de configurar os alertas de e-mail.

Na opção SMTP Server, entre com o nome do servidor onde acabou de ser configurado o servidor de SMTP. No E-mail From Address coloque um endereço de e-mail, pode ser qualquer endereço.

Pronto, agora você pode gerar algum alerta no TFS que receberá o e-mail através do gmail configurada no passo 8.

Esse procedimento pode ser utilizado para qualquer servidor de e-mail externo que você possua um usuário válido ou se na sua empresa a porta padrão de conexão com o servidor de e-mail é diferente da padrão.

Com os Events Handlers, podemos fazer mais coisas além de verificação de comentários, podemos adicionar uma complexidade maior  que exigirá alguns testes prévios e debug.

Para debugar um Event Handler e facilitar a vida, vamos adicionar o output do projeto já para a pasta padrão do Team Foundation Server, com isso o nosso Event Handler já será publicado na área de instalação e começará a funcionar sem que seja necessárias nenhuma configuração a mais ou cópia de arquivos. Para isso acesse a propriedade do projeto

Na página de propriedades do projeto, vá para aba Build e vamos adicionar a propriedade Output Path para: C:\Program Files\Microsoft Team Foundation Server 2010\Application Tier\Web Services\Plugins\

Feito isso, podemos mandar compilar o Event Handler que estamos trabalhando para que ele seja instalado.

Agora, para realizarmos um debug, vamos precisar atachar o processo do IIS que está rodando o TFS 2010. Para isso, vamos no menu Debug -> Attach Process

Irá aparecer uma lista de processos disponíveis. Procure o processo do IIS (w3wp.exe) que esteja rodando o .net framework 4.0 (caso no seu servidor possua outras aplicações no framework 4.0, você terá que identificar o processo por algum dos outros campos, o um exemplo, seria o User Name, que é o usuário que está rodando o TFS 2010)

Não esqueça de marcar a opção “Show processes in all sessions” para ver o processo do IIS. Caso você não encontre o processo do TFS, basta força uma “rodada” do TFS, para isso, vá no team explorer e dê um refresh. Isso fará que o processo “entre no ar” novamente. Feito isso, clique em Attach.

Para realizar o debug, abra uma nova IDE do VS2010, conecte no TFS e faça um check-in, com isso você poderá começar a debugar o seu código.

Espero que tenha ajudado e qualquer dúvida, não deixe de entrar em contato!

Até a próxima!

Qual a diferença? O LocalDB não fica rodando toda hora na sua máquina. Ele é um SQL Server “sob demanda”, só sobe quando você precisa, e se ficar muito tempo sem usar, ele fecha. Pra usar é fácil, basta trocar a string de conexão para usar “(localdb)\v11.0” onde antes ficava o “.\SQLExpress”, na string de conexão. Você pode inclusive se conectar nele via SQL Server Management Studio ou via as ferramentas do Visual Studio. Em tempo: o SQL Server Management Studio também não vem mais instalado.

Vejam aqui a conexã aberta no novo Management Studio (que é baseado em VS 2010):

Para entender um pouco mais, vejam este post onde o time do SQL Server anuncia o LocalDB.

Nos meus testes até aqui o LocalDB funcionou perfeitamente, exatamente como um SQL Server normal funcionaria.

Você ainda pode instalar o SQL Server Express se quiser. A versão 2012 já é final (RTM) e pode ser baixada aqui.

Acrescentar o NUnit test adapter no Visual Studio via Extension Gallery:

Instalar o NUnit via Nuget:

Opcionalmente remover a referência ao Assembly do MSTest, Microsoft.VisualStudio.QualityTools.UnitTestFramework.

Substituir os atributos do MSTest pelos do NUnit (de TestClass para TestFixture e de TestMethod para Test). Um find and replace all resolve isso rápido. Os asserts devem continuar funcionando, já que a maioria é igual nos dois frameworks, com pequenas diferenças. A classe padrão fica assim:

using NUnit.Framework;
namespace UnitTestProject1
{
    [TestFixture]
    public class UnitTest1
    {
        [Test]
        public void TestMethod1()
        {
        }
    }
}

Um teste simples de soma, seria assim:

[Test]
public void Soma()
{
    Assert.AreEqual(3, 2 + 1);
}

E rodar pelas vias normais (atalho de teclado, menu ou botão). O resultado aparece diretamente dentro do Visual Studio:

Outra coisa interessante é que essa nova janela, Unit Test Explorer, é não invasiva. Depois de rodar os testes ela aparece, mostra os resultados, e logo volta pra posição em colapso, não obstruindo seu trabalho. Os testes parecem estar rodando mais rápido também.

Tudo muito bom. É uma grande evolução com relação a versão anterior, por diversos motivos.

http://www.scrum.org/webcast

E pode ver uma lista de quem vai e discutir sobre o assunto no Facebook:

https://www.facebook.com/events/259584867461888/

Vejo vocês lá.

• Ambiente de desenvolvimento/testes;
• Avaliação de novas aplicações;
• Demonstrações de produto…

Como ex-usuário de Virtual PC (e atualmente de Hyper-V e VirtualBox), todos os meus discos virtuais estão no formato VHD. O VirtualBox (atualmente minha solução preferida de virtualização para substituir o Virtual PC) suporta o formato VHD, logo pude reaproveitar todas as minhas máquinas virtuais.

Ao longo do tempo em que usei máquinas virtuais, mais de uma vez me deparei com a necessidade de editar/modificar meus discos virtuais. As soluções nunca eram muito triviais – tipicamente passavam por algum tipo de processo de imaging (também conhecido como ghosting, termo derivado de um dos produtos mais usados para imaging de computadores, o Norton Ghost).

Mas um dia conheci o VhdResizer – e meus problemas acabaram^TM!

O VhdResizer é uma ferramenta gratuita, desenvolvida em .NET, capaz de converter e/ou redimensionar discos virtuais no formato VHD.

Com ela você pode converter discos fixos para dinâmicos e vice-versa, podendo até mesmo redimensioná-los no processo.

Um abraço,
  Igor

Surpreendentemente estável para um produto que ainda não está pronto, ele consegue ser ainda mais rápido e leve que o Windows 7 (que, por sua vez, era uma evolução GIGANTESCA em comparação com seu antecessor).

Apesar de o Windows 8 agora oferecer Hyper-V até mesmo para as versões client do Windows, eu ainda tenho máquinas virtuais no VirtualBox. Como ele funciona muito bem, não fazia sentido converter as máquinas virtuais e por isso continuei usando o VirtualBox no Windows 8.

Porém, devo admitir que nem tudo foram flores na minha relação com o Windows 8. Em especial, um problema bem irritante: a rede Wi-Fi parava de funcionar sem motivo aparente. Particularmente depois de suspender/hibernar o notebook, na volta ela sempre tinha problemas para conectar ou pegar um IP no access point. Isso aconteceu durante meu uso do Developer Preview – até o ponto em que isso estava impactando minha produtividade e tive que, forçosamente, voltar para o Windows 7.

Quando a Microsoft lançou o beta – er, digo, Consumer Preview – do Windows 8, lá fui eu de novo com a esperança renovada de que agora o Wi-Fi funcionaria sem problemas.

E não é que agora estava redondinho?!?!? 

Só que, depois de uma duas semanas de uso do Windows 8 ele voltou a dar problema no Wi-Fi. Mas dessa vez eu dei sorte e achei o culpado!

A sorte foi que demorei, depois de instalar o Windows, para reinstalar o VirtualBox. E logo depois de reinstalá-lo é que começaram os problemas. Com isso, ficou fácil de deduzir e resolver o problema de vez.

O problema deve a alguma incompatibilidade com o VirtualBox Bridged Networking Driver. É só desligar o binding do driver na placa de rede Wi-Fi e tudo volta ao normal.

Obviamente, ao fazer isso, você não poderá mais fazer bridging com a NIC Wi-Fi. Mas no meu caso isso não é um problema, portanto a solução é perfeitamente aceitável.

Um abraço,
    Igor

Thanks to all involved who shared information for this presentation and for Lambda3 for actually making the dream come true.

Somasegar, VP da Developer Division, anuncia que o beta do Visual Studio 11 e do .NET Framework 4.5 será liberado no próximo dia 29/02 com licença “Go-Live”, isto é, pode ir pra produção com suporte da Microsoft.

• Coming Soon: TFS Express

Demorou, mas o meu pedido de longa data foi atendido. Finalmente teremos um TFS Express totalmente free! Essa versão do TFS oferecerá recursos como Source Control, Build, Work Items e Agile Taskboard para até 5 usuários.

• Novidades no VLSC para atribuir assinaturas MSDN para seus desenvolvedores

Se você tem o Visual Studio instalado em sua máquina e a empresa tem a assinatura do MSDN, não deixe de pedir ao responsável pelas assinaturas para atribuir uma delas a você. Dependendo de sua assinatura, você terá horas gratuitas de Azure, treinamentos gratuitos, chamados a suporte gratuito, além de acesso a Office, Project, Visio entre outros produtos.

• Fix for Visual Studio 11 ALM Developer Preview Virtual Machine

Se você está usando a máquina virtual do Brian Keller com o Visual Studio 11 Developer Preview, o SQL Server Denalli Express (SQL Server 2012) vai expirar essa semana. Neste post, Brian explicar como corrigir o problema. (É bastante simples).

• TFS 2010: What Service Packs and Hotfixes Should I Install?

Nesta semana, o MVP de ALM, Marcelo Azuma, deu uma grande dica quando indicou o site do Grantt Holliday com todos os services packs e hotfixes que você deveria instalar em seu TFS, Visual Studio, SQL Server, SharePoint e todos os outros produtos que compõe a plataforma de ALM da Microsoft. Sem dúvida, um post para manter nos favoritos.

• How to set the SMTP Port in TFS 2010

Neno Loje, MVP e ALM Ranger, apresenta duas soluções para alterar a porta do SMTP do TFS.

• Learning about the Team Foundation Service Preview

Por volta de Setembro/2011, vários tutoriais foram publicados no Channel9 para demonstrar o TFS Preview, o TFS na Nuvem da Microsoft. Como já passou algum tempo e o produto evoluiu bastante, todos os vídeos foram regravados e agora estão utilizando a versão mais recente do produto. Se você não viu, veja agora, se já viu veja novamente!

Abraços e até a próxima.
André Dias

Um dos grandes desafios de muitas empresas que pretendem migrar do Subversion para o TFS é: como integrar meu time – e suas ferramentas – ao novo servidor?

Se você usa ferramentas que oferecem suporte nativo ao TFS – como o Visual Studio, o Eclipse (com o Team Explorer Everywhere) ou até mesmo o IntelliJ IDEA – fica mais fácil. O problema é quando o time está usando ferramentas que só sabem falar com o Subversion, tal como o Adobe Dreamweaver ou o Apple Xcode.

Para esses casos, uma alternativa pode ser o SVNBridge – um tradutor de protocolos (ou “bridge”) que emula o protocolo do Subversion, “enganando” os clientes como o Dreamweaver ou o Xcode e fazendo-os acreditar que estão conectados a um repositório Subversion, quando na verdade estão falando com o TFS.

O SVNBridge foi criado pelo time do CodePlex para que clientes SVN (em especial o TortoiseSVN) pudessem ser usados para conexão com os TFS oferecidos pelo serviço CodePlex. O time percebeu que muitas empresas poderiam se beneficiar disso e portanto decidiram compartilhar o código.

Se você já usa (ou pretende usar) o TFS e tem pessoas no seu time que dependem de ferramentas que não “falam” TFS mas “falam” Subversion, experimente o SVNBrigde!

Um abraço,
    Igor

Nascia então o “Visual Studio 2005 Team Edition for Database Professionals” (*), que oferecia recursos como controle de versão para a estrutura (“schema”) de bancos de dados, testes de unidade para código de bancos de dados (ex. stored procedures e queries), geração de dados e mais.

Quando a Microsoft lançou o Visual Studio Team System 2008, renomeou o produto para “Visual Studio Team System 2008 Database Edition”. Até aqui, o DbPro (como era conhecido o produto) era um vendido à parte – ou seja, para usar esses recursos de DDLC (Database Development Lifecycle) era necessário adquirir o VSTS Database Edition ou o venerável VSTS Team Suite (que incorporava todos os recursos disponíveis na plataforma Team System).

O problema é que, diferente do que o time de produto tinha imaginado, o grande usuário dessa ferramenta não era o DBA, mas sim o próprio desenvolvedor. Afinal, é ele quem precisa modificar o banco de dados sempre que necessário, como parte do processo de construção da aplicação. Com isso os desenvolvedores acabavam tendo que comprar duas ferramentas (VSTS 2008 Development Edition e VSTS 2008 Database Edition) para suas atividades do dia-a-dia. Desnecessário dizer que ninguém estava feliz com isso…

Em 2010 veio a primeira grande mudança de posicionamento do produto. A Microsoft, a partir do feedback recebido dos clientes, decidiu juntar as duas ferramentas – VSTS Development Edition e Database Edition – num único produto: o novo Visual Studio 2010 Premium. Além da integração, veio também a possibilidade de gerenciar bancos de dados Oracle em complemento ao suporte original a SQL Server.

Ficou confuso com essa viagem no tempo? É, não é para menos… A ferramenta originalmente conhecida como DbPro (codinome “DataDude”) passou por muitas mudanças desde que foi lançada. A única constante era o fato de que, para usar a ferramenta, era necessário comprar um produto “premium” (Team System até 2008, VS Premium/Ultimate no 2010). E como se não bastassem tantas mudanças, vem aí mais uma mudança radical:

SQL Server Data Tools (anteriormente conhecido como SQL Server Developer Tools, codinome “Juneau”) representa a nova versão da ferramenta de banco de dados anteriormente conhecida como DbPro, DataDude, VSTE for Database Professionals, VSTS Database Edition…

Reparou numa coisa estranha? Sim, agora o DbPro não é mais parte do Visual Studio. Os recursos de bancos de dados foram movidos para o SQL Server.

“Putz, agora ferrou tudo!!!” foi minha reação ao ficar sabendo da mudança. Mas antes de entrar em pânico, entenda o que muda:

• Pontos positivos:
• O DbPro/SSDT agora é gratuito. Sim, você leu direito. Gratuito. Você pode baixar o SSDT do site da Microsoft e usá-lo com qualquer SQL Server ao qual você tenha acesso;
• Pode ser usado independentemente ou integrado ao Visual Studio (2010 ou Dev11). Mesmo se o seu Visual Studio for o Professional (mas não Express).
• Pontos negativos:
• Como é um novo produto, ainda não está claro quais são as implicações da migração da ferramenta do time de Visual Studio para o time do SQL Server. Agora é aguardar o lançamento do SQL Server 2012 para termos certeza do que mudou (se é que mudou).

Para mais informações sobre o SSDT, leia o post do Gert Drapers (o Data Dude original, pai do DbPro/”DataDude”):

http://blogs.msdn.com/b/gertd/archive/2011/10/17/sql-server-developers-tools-code-named-juneau-becomes-sql-server-data-tools-ssdt.aspx

Um abraço,
    Igor

^{(*) Estou para ver empresa que goste de nome de produto comprido como a Microsoft!}

public class Classe
{
    public static string Estatico(object o)
    {
        return Metodo(o);
    }
    private static string Metodo(string s)
    {
        return "string";
    }
    private static string Metodo(object o)
    {
        return "object";
    }
}

Independente do parâmetro que eu passar para o método “Estático”, ele sempre vai chamar o método “Metodo” com parâmetro object. O que recebe parâmetro string nunca será chamado. Isso acontece porque o binding da chamada acontece em tempo de compilação, e a IL escrita identifica claramente que o método chamado é parâmetro object, já que o com parâmetro string não atende. Ao chamar o método em runtime e passar uma string, a ligação entre o método “Estatico” e “Metodo(object)” já está feita.

Estes testes servem pra confirmar isso:

[TestMethod]
public void EstaticoString()
{
    Assert.AreEqual("object", Classe.Estatico(""));
}
[TestMethod]
public void EstaticoObject()
{
    Assert.AreEqual("object", Classe.Estatico(1));
}

Existe alguma maneira de fazer com que o método que recebe uma string seja chamado? Existe. Desde que o C# incorporou características dinâmicas, em sua versão 4, é possível atrasar a resolução do overload escolhido para o tempo de execução, deixando de fazê-la em tempo de compilação. Assim, se quisermos que isso aconteça só quando a aplicação estiver rodando, basta trocar o tipo do parâmetro do método “Estatico” de object pra dynamic. Eu preferi criar outro método:

public static string Dinamico(dynamic d)
{
    return Metodo(d);
}

Esse método não sabem qual overload está sendo chamado em tempo de compilação. Isso só é resolvido quando a aplicação está rodando. Nesse momento, é possível perceber que o parâmetro é uma string e chamar o overload apropriado.

Aqui os testes:

[TestMethod]
public void DinamicoString()
{
    Assert.AreEqual("string", Classe.Dinamico(""));
}
[TestMethod]
public void DinamicoObject()
{
    Assert.AreEqual("object", Classe.Dinamico(1));
}

Interessante, não?

Coloquei todo o código no gist. Vejam lá, comentem, forkem, baixem, divirtam-se.

Com isso, o cliente nos solicitou que todos os Team Projects migrados do TFS 2008 (mais ou menos 100 projetos) recebessem o novo processo desenhado (na migração não conseguimos definir esse cenário). Então veio o desafio: como fazer todos esses 100 projetos receberem de uma só vez todos os novos grupos criados e os novos Work Items?

Para realizar tal atividade, utilizei as linhas de comando do TFS, mais especificamente TFSSecurity para a criação dos grupos e witadmin para a criação dos novos Work Items. A seguir vou mostrar o passo a passo para a realização dessa atividade.

Criação de Grupos nos Team Projects

Para criarmos grupos em todos os Team Projects de uma Collection, utilizei o comando TFSSecurity associado ao comando do FOR do DOS, pois precisava ler um arquivo texto contendo todos os Team Projects e os respectivos grupos a serem criados. Abaixo segue o passo a passo para a execução dessa atividade:

· Criação de arquivo texto – esse arquivo contem todos os Team Projects e os respectivos grupos que serão criados. Para a montagem do mesmo, me conectei ao SQL Server Management Studio e executei a instrução abaixo (conecte-se ao banco de dados com o respectivo nome de sua Collection):

SET NOCOUNT ON

DECLARE @Rows INT

DECLARE @IdCol INT

DECLARE @Project_Id NVARCHAR(512)

SET @Rows = 0

SET @IdCol = 1

CREATE TABLE #Projects

(

idcol INT IDENTITY(1,1) PRIMARY KEY CLUSTERED,

Project_Id NVARCHAR(512)

)

INSERT #Projects

SELECT project_id

FROM tbl_projects

SELECT @Rows = COUNT(*) FROM #Projects

WHILE @IdCol <= @Rows

BEGIN

SELECT @Project_Id = ISNULL(Project_Id,”)

FROM #Projects

WHERE idcol = @IdCol

IF @Project_Id <> ”

BEGIN

PRINT @Project_Id + ‘;Desenvolvimento’

PRINT @Project_Id + ‘;Homologacao’

PRINT @Project_Id + ‘;Qualidade’

END

SET @IdCol += 1

END

A instrução acima percorrerá todos os Team Projects da Collection e criará os grupos Desenvolvimento, Homologacao e Qualidade. Ao executar o comando, salve o resultado em um arquivo texto (C:\grupos.txt).

· Execução da linha de comando TFSSecurity – com o arquivo texto pronto, vamos utilizar a linha de comando TFSSecutiry em associação com o comando FOR do DOS. Para isso execute a linha de comando no prompt de comando do Visual Studio.

FOR /F “tokens=1,2 delims=; ” %i in (C:\grupos.txt) DO TFSSecurity /gc “vstfs:///Classification/TeamProject/%i” %j /collection:[URLCollectionName]

Após a execução do comando acima, vemos o resultado no Team Explorer:

Criação de Work Items nos Team Projects

Para criarmos Work Items em todos os Team Projects de uma Collection, utilizei o comando witadmin associado ao comando do FOR do DOS , pois precisava ler um arquivo texto contendo todos os Team Projects e os respectivos Work Items a serem criados. Abaixo segue o passo a passo para a execução dessa atividade:

· Criação de arquivo texto – esse arquivo contem todos os Team Projects e os respectivos Work Items que serão criados. Para a montagem do mesmo, me conectei ao SQL Server Management Studio e executei a instrução abaixo (conecte-se ao banco de dados com o respectivo nome de sua Collection):

SET NOCOUNT ON

DECLARE @Rows INT

DECLARE @IdCol INT

DECLARE @Project_Name NVARCHAR(512)

SET @Rows = 0

SET @IdCol = 1

CREATE TABLE #Projects

(

idcol INT IDENTITY(1,1) PRIMARY KEY CLUSTERED,

Project_Name NVARCHAR(512)

)

INSERT #Projects

SELECT project_name

FROM tbl_projects

SELECT @Rows = COUNT(*) FROM #Projects

WHILE @IdCol <= @Rows

BEGIN

SELECT @Project_Name = ISNULL(Project_Name,”)

FROM #Projects

WHERE idcol = @IdCol

IF @Project_Name <> ”

BEGIN

PRINT @Project_Name + ‘;Task.xml’

PRINT @Project_Name + ‘;Bug.xml’

PRINT @Project_Name + ‘;Sprint.xml’

END

SET @IdCol += 1

END

A instrução acima percorrerá todos os Team Projects da Collection e criará os Work Items Task, Bug e Sprint. Ao executar o comando, salve o resultado em um arquivo texto (C:\wis.txt).

· Execução da linha de comando witadmin – com o arquivo texto pronto, vamos utilizar a linha de comando witadmin em associação com o comando FOR do DOS. Para isso execute a linha de comando no prompt de comando do Visual Studio.

FOR /F “tokens=1,2 delims=; ” %i in (c:\wis.txt) DO witadmin importwitd /collection:[URLCollectionName] /p:%i /f:”C:\wis\%j” /v

Após a execução do comando acima, vemos o resultado no Team Explorer:

Com isso conseguimos migrar todos os Team Projects do TFS 2008 para o TFS 2010, criamos os novos grupos e atualizamos o Process Template.

Abraços e até a próxima,

Vinicius Moura.

Na sua última edição eu, Giovanni Bassi e Victor Hugo Germano estivemos presentes. Tivemos 3 pequenas apresentações, duas do Giovanni e do Victor e uma minha. Os vídeos das apresentações estão logo abaixo. Recomendo verem não somente estes vídeos, mas também os outros vídeos do conversa rápida, aproveite que eles só levam 5 ou 10 minutos.

Gostaria de parabenizar o Jonas Abreu pela organização do evento e que venham muitos outros conversas rápidas!