image

Até este momento, as únicas certificações oficiais que temos disponíveis para Scrum são disponibilizadas pela ScrumAlliance (SA), sendo elas: Certified ScrumMaster (CSM), Certified Scrum Product Owner (CSPO), Certified Scrum Practitioner (CSP), Certified Scrum Coach (CSC) e Certified Scrum Trainer (CST). Destas, as duas primeiras são focadas no SM e PO, respectivamente, a CSP é focada em qualquer membro do Scrum Team (SM, PO, time e até GPs), e as duas últimas são avançadas, focada na parte educacional (treinador e coach).

Até o momento não há nenhuma certificação focada exclusivamente no desenvolvedor, focada no time que constrói o produto. Mas tal certificação está em preparação. Em Maio do ano passado, no Brazil Scrum Gathering, o Ken Schwaber, pai do Scrum, anunciou que a SA estava se preparando para lançar uma certificação focada no desenvolvedor, e que para isso faria parcerias com empresas que se interessassem a complementar a parte de desenvolvimento, já que o Scrum não oferece grandes prescrições no desenvolvimento, sendo mais focado na parte gerencial do projeto. O primeiro parceiro anunciado foi a Microsoft.

Já faz aproximadamente um ano que a Microsoft e o Ken Schwaber estão conversando sobre esta certificação para desenvolvedores, incialmente chamada de Certified Scrum Developer (CSD). Desde então o Ken Schwaber se desligou da SA, e levou consigo o CSD. Abriu então a Scrum.org e em pouco tempo anunciou o CSD por lá, para depois renomeá-lo para Professional Scrum Developer (PSD).

Este curso, que terá sua primeira versão focada na plataforma Microsoft, será lançado junto com o Visual Studio 2010, em 12 de Abril. O foco do curso será o desenvolvedor, como já foi dito. Práticas do SM e do PO serão abordadas apenas superficialmente. O curso vai focar no profissional que faz a entrega, e, questões como preparação da visão, relacionamento do PO com os outros stakeholder, e qualquer assunto não relacionado diretamente ao desenvolvimento do software será abordado apenas o suficiente para permitir que o time trabalhe no produto. Caso exista interesse em desenvolver estas técnicas, cursos focados no SM, PO, entre outros, são mais apropriados.

Entendo este curso como o primeiro curso oficial apoiado pela Microsoft que foca somente em boas práticas de desenvolvimento, utilizando a plataforma do Visual Studio 2010 (incluindo o Team Foundation Server) para habilitar tais práticas. Ele aborda assuntos diversos relacionados a boas práticas de engenharia, arquitetura, testes, banco de dados, evolução de código legado, entre diversos outros. O curso terá uma semana, full time, onde, além da teoria, cinco sprints vão colocar o aluno frente a frente com o Scrum. Muito mais do que uma certificação, quem fizer este curso sairá com uma visão completa sobre o processo de desenvolvimento baseado na plataforma Microsoft.

Para um profissional se certificar PSD ele terá que fazer uma prova, além de participar do curso. A prova só estará disponível para quem fez o curso. O PSD não está certificando somente que o profissional participou de um curso, mas também que ele possui conhecimento suficiente para participar como desenvolvedor de um time Scrum, o que será medido pela prova.

Para ensinar este curso a Scrum.org selecionou alguns MVPs e parceiros próximos, e está em processo de treiná-los para que entreguem o curso. Os treinamentos destes instrutores estão acontecendo na Oceania, Europa e EUA, e abrangem cerca de 30 pessoas.

E porque estou contando tudo isso? Porque serei o responsável por ministrar esse curso no Brasil neste momento. Serei o único treinador disponível na América do Sul (talvez América Latina, mas não tenho certeza). Estou neste exato momento em preparação em Redmond para capacitação e montagem do curso. Estamos definindo os últimos detalhes do material e do curso, e estamos nos preparando, junto à Microsoft e ao Ken Schwaber, para entregar o melhor curso possível. Entre os outros profissionais que estarão ministrando o curso estão pessoas também altamente capacitadas e reconhecidas, que trabalham com Scrum há anos, MVPs e RDs, e todos profundos conhecedores da plataforma de ALM da Microsoft. (Não vou nomeá-los neste momento porque alguns ainda estão preparando sua estratégia de lançamento.)

Estou preparando um site com mais informações sobre o curso. Em breve colocarei no ar o http://www.scrumdev.com.br onde você poderá ler mais sobre o assunto, assim como se inscrever no curso. A primeira turma já está praticamente fechada, e conta com profissionais de grandes empresas brasileiras e multinacionais, e deve acontecer já em Abril. Estou planejando uma segunda turma também em Abril e assim que estas informações estiverem mais definidas avisarei por aqui. De qualquer forma, se você quiser participar das primeiras turmas planeje uma semana fora do trabalho, já que o curso vai tomar uma semana inteira, e é bem puxado. E fique atento nas datas, porque há uma demanda represada por este curso não só no Brasil mas em toda a américa do Sul, e as salas tendem a encher logo.

Aos colegas de Java, aviso que o curso de Java já está em preparação. Conheci os profissionais que estão preparando o curso, e tudo indica que utilizará Eclipse como ferramenta. Perguntei hoje ao Ken Schwaber quando o curso será lançado, e ele espera começar a preparação dos treinadores no terceiro trimestre de 2010, ou seja, devemos esperar cursos de PSD lá pelo final do ano.

Mais informações sobre o PSD podem ser obtidas no site da certificação no Scrum.org. Os cursos serão anunciados aqui, no scrumdev.com.br, e no site da Scrum.org.


Postado na(s) categoria(s) Certificação , Scrum , Scrum Developer pelo Giovanni Bassi em 23 de fevereiro de 2010 às 05:57 | Tags: , ,

Welcome do the MVP Summit!

Sexta-feira, dia 19, terminou o MVP Summit de 2010. Eu falei das minhas primeiras impressões no último post.

O Summit foi um evento muito legal, do jeito que eu esperava. Assisti palestras excepcionais. Vi uma palestra do Erik Meijer, que é um dos pais do LINQ, que foi fantástica. Não posso revelar o que foi falado (NDA), mas posso dizer pra vocês que o Erik é maluco, no melhor sentido da palavra. Ele deu uma palestra incrivelmente empolgante, interagiu com todos o tempo todo, e não parou um minuto. Ninguém queria ir embora.

Campus da Microsoft

Além destas palestras outras muito boas aconteceram. Os MVPs brasileiros de XBox, o Mauricio Alegretti e o DocAraxa viram o projeto Natal ao vivo, jogaram nele, e contaram do que acharam aqui (adianto: adoraram!). O Diego Nogare eu nem vi, ficou preso com o time de SQL Server, assim como o Igor Abade e o Ramon Durães, que não saim de perto do time de Visual Studio. Vejam no blog do Rodolfo Roim, MVP Lead no Brasil, onde há um link pros blogs do MVPs pra ver outras impressões, além da impressão do próprio Rodolfo.

No Facebook vocês também acompanham o summit, assim como no twitter é possível ver o que foi dito na hashtag #MVP10.

Na quarta-feira houve um jantar pra receber os MVPs, separado por competência. Os MVPs de C#, VB e VSTS se reuniram no mesmo jantar:

Jantar de MVPs no Summit

Ganhamos uma bela jaqueta do Visual Studio:

Ganhamos a jaqueta!

Outra coisa muito legal foi ter visitado um “museu” dentro da Microsoft. Logo na entrada você dá de cara com um globo super bonito, com informações atualizadas em tempo real.

Globo no museu da MS

Por exemplo, na hora que estávamos por lá, entre os assuntos mais procurados no Bing no Brasil estavam, infelizmente, “Seio Ivete Sangalo”, “Horóscopo”, “Mulher melancia”, como vocês podem ver nessa foto com o sorridente Alfred:

Assuntos mais comentados no Brasil no Globo da MS

Mais algumas fotos do globo:

Mais do globo da Microsoft Mais do globo da Microsoft Mais do globo da Microsoft

Quero um desses em casa. :)

Mais algumas do museu:

Museu da Microsoft Museu da Microsoft

Aqui vocês vêem o Carlos dos Santos jogando Forza 3 no XBox com uma tela gigantesca. Eu também joguei e nem preciso dizer que é muito divertido, né?

XBox em tela gigante no museu da Microsoft

Foi muito engraçado ter descoberto que o Mr. Simpson trocou a planta atômica pela Microsoft:

Homer Simpson trabalhando na Microsoft?

(Sim, o boneco realmente estava lá, não é montagem)

Na quinta à noite fomos para uma festa preparada pela Microsoft em uma casa noturna de Seattle chamada “The Garage”:

Festa do MVP Summit no The Garage

Bebida e comida à vontade, de vários lugares no mundo:

Algumas opções de bebidas na festa

Além disso, bilhar e boliche. A noite foi ótima. A Microsoft realmente cuida dos MVPs.

No dia seguinte tivemos os últimos keynotes, um almoço de despedida e as últimas palestras. Uma dela foi a minha:

Giovanni Bassi palestrando no MVP Summit 2010

Foi minha primeira palestra internacional, ministrada para um público bem exigente, formado por MVPs, RDs e funcionários da Microsoft. Dada a exigência do público, minha preparação foi feita à altura, e a palestra foi muito bem recebida. Pretendo palestrar de novo ano que vem.

Tchau MVP Summit 2010

À noite fomos comer caranguejo, na verdade King Crab, em um restaurante em Seattle. Foi, pra dizer o mínimo, uma experiência única. Eles trazem as patas do caranguejos e jogam na mesa. Cada um se vira com um martelinho pra comer. Delicioso, e exótico. Aqui vocês vêem o Igor Abade, JALF, Rodolfo Roim, DocAraxá, Maurício Alegretti e eu com a arma na mão.

MVPs comendo no Crab Pot em Seattle

Com isso terminou o Summit. E vocês acham que acabou? Não acabou, até agora não tive descanso. Sábado eu iniciei um curso com o Ken Schwaber (um dos criadores do Scrum) para preparação do Professional Scrum Developer (PSD), idealizado pela Scrum.org, que irei começar a ministrar no Brasil em Abril, e sigo em preparação essa semana na Microsoft. Mas isso é assunto para outro post. Provavelmente amanhã falo do PSD.


Postado na(s) categoria(s) Eventos pelo Giovanni Bassi em 22 de fevereiro de 2010 às 04:43 | Tags: ,

MVP Global Summit 2010

Estou em Seattle/Redmond/Bellevue (depende do dia). Vim pra cá pra participar do MVP Summit 2010. Esse é o evento que reune os MVPs do mundo inteiro para discutir tecnologia Microsoft. Todos estão sob NDA (Non Disclosure Agreement – Acordo de confidencialidade), então a Microsoft mostra tecnologias que vão ser lançadas em um, dois, três anos pra frente. Assuntos que esperamos sãp: próximas versões do Visual Studio (pós 2010), do Office (pós 2010), do Windows, projeto Natal, entre outros.

Infelizmente, por causa do NDA, não podemos comentar tudo que ouvimos, mas o que eu puder trazer pra vocês do evento vou contar aqui.

Hoje o dia é de registro:

Crachá MVP Summit

Já tivemos palestras de MVP para MVP, e agora teremos o keynote, com o Toby Richards (GM de Community & Online Support), depois da abertura do Nestor Portillo (diretor de Community & Online Support). À noite temos um jantar, e amanhã teremos reuniões e palestras, onde os MVPs vão interagir com pessoas relacionadas às suas competências. Quinta será assim também, e sexta teremos mais sessões de MVPs para MVPs, onde eu vou também palestrar.

Nem preciso dizer que é muito legal estar aqui. O MVP Summit traz MVPs do mundo inteiro, e há mais nacionalidades representadas aqui (84) do que nas olimpíadas de inverno (81), que estão acontecendo agora. Um ambiente desses traz ao ordinário o que é extraordinário. Estar em um ambiente onde todos são experts em alguma área específica não acontece toda hora. Para todo lado onde se olha há MVPs e RDs.

MVPs no Summit

Nos próximos dias vou trazer pra vocês como o evento está evoluindo. Fiquem ligados.


Postado na(s) categoria(s) Eventos pelo Giovanni Bassi em 16 de fevereiro de 2010 às 21:19 | Tags: ,

5_on_target Tenho estudado um pouco sobre motivação, principalmente por causa das consultorias que tenho feito. Tenho encontrado todos os dias confirmações de que temos grandes erros acontecendo no meio corporativo. Hoje eu quero falar da medição de performance e seu impacto na motivação e na entrega, e para isso vou começar com um texto que vem do livro “Agile Software Development – The Cooperative Game” do Alistair Cockburn e está disponível no site dele também, onde há um capítulo de exemplo (veja minha review na página de livros indicados).

Picking Dandelions
Dandelions were beginning to clutter our back yard. Having three children aged 10 and under, I concocted a brilliant solution: I offered them one cent per yellow flower and ten cents for any dandelion in the seeding stage. For five to ten dollars a year, I thought, we’d get rid of dandelions in a few years.
The kids brought in bags of dandelions, and I paid out the cash.
On the third year, I commented to my now 12-year-old, Cameron, that it looked like we had more dandelions than the previous year.
He said, “Sure. Last year I ran around, dancing and waving all the white dandelions around. When Sean asked why I wasn’t just putting them into the bag, I said, ‘I’m planting money for next year!’” ”

Traduzido:

Pegando dentes-de-leão
Dentes-de-leão estavam se amontoando em nosso quintal. Tendo três filhos com 10 ou nenos anos, eu inventei uma solução brilhante: lhes ofereci um centavo por uma flor amarela e dez centavos por semente de dente-de-leão. Por cinco a dez dólares por ano, pensei que nos livraríamos de dentes-de-leão em poucos anos.
Os garotos trouxeram sacos de dentes-de-leão, e eu paguei em dinheiro.
No terceiro ano, eu comentava com meu filho Cameron, agora com 12 anos, que parecia que tínhamos mais dentes-de-leão que no ano anterior.
Ele disse: "Claro. No ano passado eu corri em volta, dançando e agitando todos os dentes-de-leão. Quando Sean perguntou por que eu não estava só colocando-os dentro do saco, eu disse: 'Estou plantando dinheiro para o próximo ano!" ”

É um texto curto e divertido, não é? Quem iria esperar esse final de história? Somente quem já está acostumado com os conceitos que vou expor neste post agora. Os conceitos ainda estão um pouco brutos, estou estudando ainda para depurá-los, há livros para comprar, e muito mais estudo a fazer. Este post é um primeiro passo para trazer isso para vocês.

Vamos tentar entender o que aconteceu com Alistair, qual foi o problema que ele teve? Ele estava pagando por entrega, ou seja, por dente-de-leão. Seu filho entendeu isso. Nada mais racional do lado de Alistair do que prever que em pouco tempo estaria livre das plantas. Mas ele não contava que os incentivos dele eram diferentes dos incentivos do seu filho. Para ele, o objetivo era limpar o jardim. Para seu filho, o objetivo era ganhar o máximo de dinheiro possível fazendo algo que o pai pediu. Quem ouvisse a história até a metade nunca saberia que havia uma divergência entre os incentivos de cada um. Eles pareciam idênticos, até o problema aparecer.

O primeiro problema então é a falta de comunicação. O pai deveria ter deixado claro que o objetivo era limpar o jardim.

Ainda assim, há um segundo problema. Mesmo que a comunicação se desse conforme o esperado, isso não significaria que o filho iria sustentar o objetivo do pai, e não o seu. Seus objetivos eram claramente conflitantes, já que para o filho ganhar muito dinheiro sempre deveriam haver muitos dentes-de-leão no jardim.

Vamos fazer um paralelo com a forma com que a indústria de software remunera seus funcionários. Entre os mais comuns estão:

  • salário mensal + hora extra,
  • salário mensal e hora extra proibida,
  • pagamento por hora,
  • pagamento por linha de código,
  • pagamento por entrega.

Assumindo que os funcionários tem como objetivo ganhar o máximo de dinheiro possível, o que vai acontecer nos cenários onde a remuneração é atrelada ao tempo, como nos casos de salário mensal + hora extra, e pagamento por hora? Se para o funcionário ganhar mais, ele precisa trabalhar mais, então ele vai ter que ter trabalho pra fazer. Isso implica que se ele fizer tudo no horário certo e for pra casa, ele não vai maximizar seu salário. Para reverter isso, ele tem algumas opções: deixar os bugs correrem soltos e depois corrigir na hora extra, inventar funcionalidades desnecessárias ao projeto (goldplatting), inventar trabalho (análises desnecessárias, etc), trabalhar com arquiteturas difíceis de manter, tentar aumentar o escopo do projeto, e por aí vai. Nenhuma destas opções é boa para o projeto, mas são boas para o salário do desenvolvedor. E esses dois casos sozinhos devem ser a maioria do mercado.

Há o caso do pagamento por linha de código. Nesse caso, fica óbvio que o desenvolvedor vai criar a maior quantidade possível de linhas de código. Vai comentar tudo, vai criar declarações desnecessárias, loops que pouco fazem e por aí vai. Já imagine classes de 2 mil linhas e o inferno de manutenção. Pelo menos o pagamento por LoC é raro hoje em dia.

No pagamento por entrega, o objetivo é entregar. Nesse cenário, o desenvolvedor vai focar na entrega. Não vai inventar nada que não esteja focado na entrega, porque se isso acontecer o pagamento dele diminui ou atrasa. O problema é que nesse cenário o desenvolvedor faz a entrega a qualquer custo. Mesmo que para entregar mil reais em valor ele precise destruir dois mil reais. Se ninguém estiver medindo onde os 2 mil reais foram perdidos, então tudo bem. E não imagine que você vai conseguir resolver o problema na engenharia ou no conceito de pronto, porque ele vai dar um jeito de dar a volta nesses conceitos. Exemplo: precisa de testes, ok, vamos fazer testes inúteis, que não tomem tempo. Além disso, ele vai barganhar no custo de cada entrega, dizendo que as coisas são maiores do que são.

Em todos esses casos há ainda o problema do hiperfoco. O desenvolvedor hiperfocado na meta não olha para os lados, não pensa criativamente. E desenvolvimento de software é um trabalho criativo, ou seja, a performance do desenvolvedor vai cair caso você faça ele focar, porque ele não vai conseguir resolver os problemas. Há diversos estudos comprovando isso (vou colocar algumas referências no final).

Sobra somente o caso do salário mensal e hora extra proibida. Nesse caso, o desenvolvedor ganha sempre a mesma coisa, não importa o que faça. A motivação vai ter que vir de outro lugar. Se a empresa não motivá-lo ele vai virar uma pessoa apática, mas pelo menos não vai fazer 70 horas por semana e criar um monte de bugs. Como motivá-lo vai ficar para outro post, tenho coisas a falar sobre isso também.

O que eu quero que vocês levem deste post é: o que é reconhecido é feito. Se você pagar ou valorizar número de testes, espere ver milhares de testes na aplicação, mas não necessariamente testes efetivos. Se você valoriza linhas de código, os programas vão ser gigantescos, e por aí vai, você já entendeu.

“- Mas nem todo mundo quer maximizar o salário a qualquer custo”, vocês certamente dirão. Sim, há pessoas que possuem outros motivadores, mas os problemas que estou levantando acontecem a todo momento. A questão é criar uma cultura que incentive a automotivação, e não a motivação externa, mas, como eu disse, isso é assunto para outro post.

Eu trabalhei um bom tempo com uma metodologia muito interessante, que defendi por um bom tempo, o Balanced Scorecard. Hoje me preocupo muito com o BS em projetos criativos, pelos motivos que já citei. E pior, o BS é público, ou seja, não é só você se medindo, é a empresa inteira te medindo junto. Uma péssima ferramenta para motivar o funcionário. Se o objetivo é medir, meça, mas não divulgue, mantenha os dados na mão do gestor, que vai saber onde há problemas. No momento em que você libera a informação dos valores medidos o funcionário passa a se medir por ela.

Algumas referências interessantes sobre o assunto:

Veja esta palestra do Dan Pink sobre motivação. É de cair o queixo e ele compara o que a ciência sabe e o que as empresas fazem, e como isso não bate. Tem legenda em português:

Veja esta palestra sobre métricas ágeis apresentada no Agile 2009, disponível no InfoQ. Diversos fundamentos são colocados.

Veja o livro “Measuring and Managing Performance in Organizations”, citado na palestra acima. Ainda não li, mas está na minha lista.

E entenda o que um trabalhador do conhecimento quer de uma empresa, nesta thread do .Net Architects.


Postado na(s) categoria(s) Gestão de projeto pelo Giovanni Bassi em 10 de fevereiro de 2010 às 00:03 | Tags: , , ,

image

Dia 26 de janeiro fiz um webcast sobre design patterns. Expliquei um pouco o que são, onde devem ser utilizados, apresentei alguns padrões, mostrei alguns dos problemas no seu uso, e falei também sobre padrões de arquitetura. Abordei os seguintes padrões:

  1. Strategy
  2. Template Method
  3. Factory method
  4. Abstract factory
  5. Singleton

A gravação já está disponível no media center do MSDN. Acesse aqui.

A apresentação:

Os links:

Design Patterns:
http://dofactory.com/Patterns/Patterns.aspx
http://en.wikipedia.org/wiki/Design_Patterns

Padrões de Arquitetura (Fowler):
http://martinfowler.com/eaaCatalog

Na MSDN Magazine:
http://tinyurl.com/msdnmagdp1
http://tinyurl.com/msdnmagdp2

 

Na página de livros indicados há o livro de padrões que recomendo, e o do GoF.


Postado na(s) categoria(s) Eventos , Arquitetura pelo Giovanni Bassi em 9 de fevereiro de 2010 às 08:05 | Tags: , ,

Agile Brazil 2010

O Agile Brazil, maior conferência do país (da qual faço parte da organização), está recebendo propostas para quem quiser palestrar. Para quem tiver interesse basta acessar submissoes.agilebrazil.com, se cadastrar e submeter uma proposta de palestra. O cadastro é rápido e você pode editar suas palestras a vontade no sistema de submissão.

O evento vai ser de 22 a 25 de Junho em Porto Alegre, e está prometendo ser um grande evento. Se você está envolvido com práticas ágeis, ou tem algo pra contar, entre lá e submeta sua palestra. Você vai palestrar ao lado de grandes figuras, como Martin Fowler, Philippe Kruchten, David Hussman, Klaus Wuestefeld, entre outros. Está bom, né?

Tem uma trilha chamada “Relatos de experiências” que eu acho especialmente interessante. Você não precisa ser uma referência no assunto, basta ter passado por alguma experiência com agilidade que você entenda que será útil que outras pessoas fiquem sabendo, seja ela de sucesso ou não. Eu já ouvi diversas experiências que gostaria de ver retratadas em palestra, espero que essas pessoas submetam propostas.

Além disso há trilhas para gestão, engenharia, e interesse geral. Ou seja, se você tem algo pra dizer, vai lá. Só aceitaremos propostas até o final deste mês, então fique atento para não deixar para a última hora.

Eu vou submeter palestras. Mais de uma. Vamos ver se uma delas é selecionada.


Postado na(s) categoria(s) Agilidade pelo Giovanni Bassi em 9 de fevereiro de 2010 às 04:13 | Tags:

image[2]

Amanhã (quinta, ou hoje (4/fev), se você estiver vendo um dia depois que escrevi isso), tem um webcast apresentado pelo Luciano Condé, arquiteto da Microsoft Brasil. Eu vou moderar o webcast, ou seja, vou responder as perguntas que aparecerem.

Pra assistir e só clicar a aqui. É ao meio dia.


Postado na(s) categoria(s) Eventos pelo Giovanni Bassi em 3 de fevereiro de 2010 às 19:37 | Tags: ,

Hã? Livros? Atualizei a lista de livros recomendados. Vão lá olhar.


Postado na(s) categoria(s) Indicação de conteúdo pelo Giovanni Bassi em 3 de fevereiro de 2010 às 04:14 | Tags: , , ,

Na outra semana eu fiz um webcast sobre IronRuby com o Alessandro Binhara, do Mono Brasil. Ele falou de IronPython e bastante de DLR, e eu foquei no IronRuby. Fiz algumas demos bem interessantes, incluindo algumas que mostrei aqui no blog, já que tenho falado bastante de IronRuby por aqui. O webcast fez parte da semana de interoperabilidade do MSDN, e foi muito bem, como vocês podem ver nesse e-mail do Rodrigo Dias da Microsoft publicado no Mono Brasil.

O webcast começou com o Binhara falando por uns 40 e poucos minutos sobre Python e DLR, e depois eu encerrei com mais 40 minutos de Ruby. Foi uma hora e meia de webcast!

Aqui estão os recursos da palestra:

Clique aqui para assistir à gravação.

Links da palestra:

  1. Ruby language
  2. IronRuby
  3. IronRuby.info
  4. IronRuby no Codeplex
  5. John Lam
  6. Jimmy Schementi
  7. Rails
  8. RSpec
  9. Cucumber
  10. Ruby Inside

Postado na(s) categoria(s) IronRuby , Eventos pelo Giovanni Bassi em 3 de fevereiro de 2010 às 02:47 | Tags: ,

image[1]

Este é o quinto post sobre IronRuby. Veja os anteriores:

  1. Rodando Ruby com C#: Parte 1
  2. Rodando Ruby com C#: Parte 2 – chamando uma classe Ruby no C#
  3. Rodando Ruby com C#: Parte 3 – chamando uma classe C# a partir do Ruby
  4. Rodando Ruby com C#: Edição especial: ASP.Net MVC 2.0, .Net 4.0 e Visual Studio 2010

Este é o post que eu queria escrever desde o começo. Nele vou mostrar um exemplo de uso real do IronRuby na sua aplicação, vou jogar uma idéia, que vai dar a vocês muitas outras idéias.

A idéia é que tenho uma aplicação feita com C#, mas tenho um pequeno pedaço da minha regra de negócios que quero deixar o usuário editar. Uma opção alternativa seria criar um formulário onde o usuário poderia tentar compor uma regra com textboxes, checkboxes e outros controles, e funcionaria, só que eu limitaria a liberdade do usuário na criação da regra. Com IronRuby posso dar o potencial do cliente escrever a regra em código.

Observação: A princípio eu ia fazer com ASP.Net MVC, usando C#. Por algum motivo não está rodando. Os testes funcionam, e funciona com uma aplicação console, mas não funciona com ASP.Net, seja MVC ou Webforms. Se alguém quiser testar, e não funcionar, votem lá no Codeplex para que o time possa olhar. O bug está aqui. Clique aqui para baixar a solution para testar. O projeto original com MVC está lá, assim como o de WebForms.

Como ficou o projeto:

Criei uma camada de apresentação em console app, só com C#, uma camada de domínio com C# e IronRuby, e os testes, só em C#, e às vezes passando código em IronRuby para testar.

Criei um sistema de pedidos. O cliente pode solicitar um pedido. Vejam as entidades:

Dessas, vale a pena ver a de pedido:

public class Pedido
{
    public Cliente Cliente { get; set; }

    public Pedido(Cliente cliente)
    {
        if (cliente == null)
            throw new InvalidOperationException("Cliente não pode ser nulo.");
        Cliente = cliente;
    }

    private List<ItemPedido> _itens = new List<ItemPedido>();

    public void Adicionar(ItemPedido itemPedido)
    {
        _itens.Add(itemPedido);
    }

    public IEnumerable<ItemPedido> Itens { get { return _itens; } }

    public decimal Valor
    {
        get
        {
            return _itens.Sum(i => i.Quantidade * i.Produto.Preco);
        }
    }

    public int Id { get; set; }
}

As classes do projeto são simples, sem grandes comportamento, praticamente só getters e setters. A classe de pedido é mais esperta e expõe apenas os itens como um Enumerable, mas só permite incluir itens através de seu método.

Há dois serviços também:

O ServicoCriacaoDePedido cria pedidos com o método Criar, passando a eles um objeto de valor chamado de CriarPedido:

Ele então retorna um pedido criado.

O serviço mantém ainda na propriedade RegrasPosCriacaoDoPedido uma lista estática de regras que acontecem após a chamada de criação do pedido.  Você pode criar regras chamando o método Incluir, e pode limpá-las chamando o método Limpar.

Quando o serviço criar um pedido, ele submete o pedido ao método privado RodarRegraSobreOPedido. É lá que as regras são aplicadas. As regras podem ser envio de e-mails, descontos, etc. Vejam a classe de regras:

public abstract class AposCriacaoPedido
{
    public AposCriacaoPedido()
    {
        Id = Guid.NewGuid();
    }
    public abstract void Rodar(Pedido pedido);
    public string Codigo { get; set; }
    public Guid Id { get; set; }
}

Tem um método rodar, que recebe um pedido e é abstrato, ou seja, vai ter que ser implementado por clases herdeiras. É neste método que acontece a regra. A classe tem ainda um Id para identificação. A parte onde você percebe que há algo diferente é na propriedade Codigo. É lá que fica o código do IronRuby. Ele fica lá apenas para referência, já que, vocês verão em breve, teremos classes IronRuby filhas desta classe.

É aí que entra o serviço de criação de regras, a outra classe de serviços, a da direita. Ela tem somente um método público chamado CriarRegraPosCriacaoPedido. Bamos vê-lo:

public AposCriacaoPedido CriarRegraPosCriacaoPedido(string codigo)
{
    const string templateDoMetodo =
        @"
        include RegrasDinamicas::Model
        class {0} < AposCriacaoPedido
            def Rodar(pedido)
                {1}
            end
        end";

    var nomeClasseTemp = "AposCriacaoPedido_" + Guid.NewGuid().ToString().Replace("-", string.Empty);
    var codigoCompleto = string.Format(templateDoMetodo, nomeClasseTemp, codigo);
    _engine.Execute(codigoCompleto, _scope);
    var classe = _runtime.Globals.GetVariable<RubyClass>(nomeClasseTemp);
    var retornoCriacao = _operations.CreateInstance(classe);
    var aposCriacaoPedido = (AposCriacaoPedido)retornoCriacao;
    aposCriacaoPedido.Codigo = codigo;
    return aposCriacaoPedido;
}

Notem que este método cria com código Ruby uma classe com nome aleatório. O template desta classe é uma string, que possui dois placeholders. O zero é o nome da classe, gerado via Guid, e colocado na variável nomeClasseTemp para depois ser substituído no template. O placeholder 1 é o corpo do método da regra, passado pelo usuário, e que fica na variável codigo. O código completo fica na variável codigoCompleto. A classe gerada herda da classe de regras, e portanto pode ser instanciada e feito cast dela de uma classe dinâmica do Ruby para a classe do C#. A partir daí, a classe de regra está gerada. Ela recebe na propriedade Codigo o código passado pelo usuário, e é então repassada para o chamador, que a coloca na coleção estática de regras do serviço de criação de pedidos, que a aplica sempre que um pedido é criado.

O resto desta classe de serviço é código de infra que já vimos nos outros posts.

Tem mais uns negócios interessantes no projeto, como repositórios, e um padrão MVC para escrita na console. Vale a pena dar uma olhada.

A partir daí é só utilizar. Vejam o controller de regras (um pouco resumido):

class RegrasController : IRegrasController
{
    private IList<AposCriacaoPedido> _regras;
    private IRegrasView _regrasView;
    private readonly ServicoCriacaoDeRegras _servicoCriacaoDeRegras = new ServicoCriacaoDeRegras();

    public RegrasController(IRegrasView regrasView)
    {
        _regrasView = regrasView;
    }

    public void ExibirRegras()
    {
        if (_regras == null)
            _regras = ServicoCriacaoDePedido.RegrasPosCriacaoDoPedido.ToList();
        var proximaAcao = _regrasView.Listar(_regras);
        proximaAcao(this);
    }

    public void CriarNova()
    {
        var proximaAcao = _regrasView.ExibirNova();
        proximaAcao(this);
    }

    public void CriarNova(string codigo)
    {
        var regra = _servicoCriacaoDeRegras.CriarRegraPosCriacaoPedido(codigo);
        ServicoCriacaoDePedido.IncluirRegraPosCriacaoDoPedido(regra);
        _regras = null;
        ExibirRegras();
    }

    public void ExibirRegra(int posicaoSelecionada)
    {
        if (posicaoSelecionada == -1)
            return;
        var pedido = _regras[posicaoSelecionada];
        var proximaAcao = _regrasView.ExibirRegra(pedido);
        proximaAcao(this);
    }
}

Posso listar as regras, que passa pelo método ExibirRegras:

Posso listar uma regra:

Notem no método CriarNova, que o serviço de regras é utilizado. Isso me permite criar uma regra (com multi line):

E entao executá-la ao inserir um pedido:

Note a mudança no preço. Ao alterarmos o preço de um produto, todos os pedidos mudam (pequeno erro de modelagem…).

O código está disponível para vocês baixarem. Depois vou postar sobre o MVC que usei no projeto, que achei que ficou interessante.


Postado na(s) categoria(s) IronRuby pelo Giovanni Bassi em 2 de fevereiro de 2010 às 03:00 | Tags: , ,

Quer me fazer alguma pergunta?

Manda lá no Formspring:

http://www.formspring.me/giovannibassi


Postado na(s) categoria(s) Outros pelo Giovanni Bassi em 29 de janeiro de 2010 às 02:13 | Tags:

Escreva um teste e você tem uma aplicação que não vai falhar naquele ponto, naquele dia – porque você vai esquecer de rodar aquele 1 teste sempre que alterar a aplicação. Desenvolva toda sua aplicação com TDD e você terá uma aplicação mais confiável e com um design melhor.

Utilize um scrum board, e faça reuniões diárias, e o projeto terá transparência. Pratique o Scrum por inteiro e você terá mais transparência, mais software entregue, melhor integração no time, mais visibilidade sobre os resultados, mais confiança no planejamento.

Refatore sempre e você terá código limpo. Refatore de vez em quando… se você conseguir.

Escreva um post no blog hoje, outro daqui um mês ou dois, outro vai saber lá quando e você terá um blog que ninguém visita. Escreva no blog sempre que encontrar alguma coisa que a comunidade pode crescer ao ler, dedique tempo a ele, não deixe ele morrer sem posts, invista no conteúdo, aprenda a escrever, e você terá um blog que é referência, e que ganha visitantes mês a mês.

Escreva um artigo em uma revista hoje, dê uma palestra ano que vem, responda uma pergunta no fórum daqui um uns meses, participe de vez em quando de uma reunião do grupo de usuário que você é parte e você será um consumidor de informação que eventualmente publica alguma coisa. Já é mais do que a maioria, mas se você quer realmente fazer diferença publique artigos com regularidade, palestre sempre que for convidado e busque eventos para contar o que sabe, participe ativamente de um fórum, assuma uma posição de moderação, tome uma posição de liderança do grupo de usuários que participa (seja cuidando da revista, do podcast, do dojo, moderando o fórum, etc). Você será reconhecido na comunidade, as pessoas vão lembrar de você, e quem sabe você até não é nomeado MVP.

Faça exercícios essa semana inteira. Semana que vem faça alguns dias, depois não faça mais. Você perdeu seu tempo. Faça com uma frequência definida, e você vai entrar em forma.

Toque um instrumento sempre e você tocará bem. Toque de vez em quando e você só vai fazer barulho.

.

.

.

Disciplina é chave em praticamente todas as disciplinas humanas. Não espere grandes resultados em atividades que você não se dedica. Fazer pela metade geralmente é igual ou quase igual a não fazer nada. Vai iniciar um projeto ágil? Faça direito, aplique as praticas recomendadas, elas estão lá por um motivo. Vai estudar padrões de projeto? Aprofunde-se no assunto, leia livros, pratique. Só assim você vai ser um desenvolvedor, analista, gestor melhor.

Ou entendemos isso ou continuamos eternamente na mediocridade.


Postado na(s) categoria(s) Dicas pelo Giovanni Bassi em 25 de janeiro de 2010 às 08:04 | Tags: , , , ,

Na próxima terça feira, dia 26/01/2010, ao meio dia, vou fazer um webcast de padrões de projeto. Pra quem quiser participar é só clicar aqui.

Update: Quem quiser assistir, a versão gravada está aqui.


Postado na(s) categoria(s) Eventos pelo Giovanni Bassi em 24 de janeiro de 2010 às 12:07 | Tags: ,

280px-Penrose_triangle_svg Eu uso o termo “engenharia de software”. Quem já viu uma palestra minha, leu um artigo, ou frequenta este blog sabe disso. Só que já tem um tempo que tenho um certo problema com o termo. Principalmente porque o termo “engenharia” parece carregar práticas que não se aplicam em sua totalidade à criação de algo tão etéreo como software. Nas palestras que dou sobre engenharia de software ou processos logo no começo eu deixo claro que há uma grande diferença entre o que fazemos e o que um engenheiro civil faz. Comparo a criação de software com a construção de uma ponte e também com o litigar de um caso na justiça, e ressalto que há elementos de um, como de outro, mas que ainda assim não é um, como não é o outro.

Eu mudei de idéia. Não me incomodo mais com o termo. Quem me fez mudar de idéia foi a segunda edição do livro “Agile Software Development – The Cooperative Game” do Alistair Cockburn. Estou gostando muito do livro, e ele entra nesta discussão, perguntando se desenvolvimento de software é ou não engenharia. A resposta é: sim, é; e faz sentido.

A questão é que normalmente vemos engenharia de software como “ciências aplicadas”. O engenheiro é alguém com profundo conhecimento de matemática, física, química, e talvez outras ciências naturais, que faz uso deste conhecimento para criar coisas materiais. Ele utiliza seu conhecimento de física e de determinado material para determinar o tamanho de uma viga, dada a carga que ela vai ter que suportar, por exemplo. Só que o engenheiro não é só isso.

É verdade que o engenheiro deve aplicar o conhecimento das ciências naturais para resolver os problemas que encontra. Mas isso não significa que as perguntas que ele deve fazer para resolver os problemas com o qual ele se depara vêem tão matematicamente quanto as respostas para tais perguntas, ou ainda que ele as formule sozinho.

O que normalmente acontece é que um engenheiro, independentemente da área, terá que buscar de maneira criativa a pergunta correta para resolver um problema. Somente depois de fazer a pergunta certa – e pode haver mais de uma, cada uma resolvendo o problema com diferentes graus de exatidão – é que ele vai poder aplicar seus conhecimentos das ciências exatas. Até então ele está trabalhando criativamente, utilizando o conhecimento das ciências exatas em conjunto com diversos outros, combinando-os de maneiras aleatórias, ou utilizando técnicas de análise, para chegar em perguntas candidatas, que podem ser testadas, ou não, até que uma seja escolhida como a mais apropriada. E depois de resolver a pergunta escolhida, ela pode acabar não atendendo o problema de maneira satisfatória, e o processo começa de novo, só que desta vez após um grande processo de aprendizado ter acontecido, com um engenheiro agora mais preparado, e que vai olhar suas opções com mais abrangência e profundidade do que aconteceu na primeira iteração. O conhecimento gerado com a primeira iteração, tenha ela tido sucesso ou não, não tem preço, e só pode ser ganho desta forma, e não lendo um documento com as experiências de outra pessoa, por exemplo. Experiência não se compra.

Esse processo ocorre também em grupos, onde um time de engenheiros, e possivelmente alguns não-engenheiros, se reune para discutir um problema, e como vão resolvê-lo. Nesse caso, além de todo o processo de criatividade e invenção já citado, há ainda todo o processo de comunicação, que nada tem a ver com uma ciência natural como a física ou a matemática. O problema é sempre formulado por alguém, que não é o engenheiro. Isso significa que o engenheiro nunca está só, e o processo de comunicação sempre existe. E se há comunicação estamos abrindo as portas para atividades que nada tem a ver com matemática ou física. Assuntos como negociação, persuação, hierarquia, relacionamento interpessoal, entre outros, passam a preocupar o engenheiro, que não deve mais se restringir a números, vigas, ou a resistência de materiais.

Diante desta visão, fica mais fácil dizer que engenharia de software existe, sim. Da mesma forma, temos atividades mais exatas, como a aplicação de algum padrão de projeto, ou de polimorfismo, por exemplo, mas temos também atividades relacionadas a comunicação, como reuniões diárias, e o pareamento. Nesses momentos estamos trabalhando nossa capacidade inventiva e comunicativa para buscar as perguntas corretas para atender determinado caso de uso história. Nesse cenário o engenheiro civil é mais parecido com o engenheiro de software do que pensávamos; temos os processos mais exatos, mas eles são somente parte da prática, já que temos também os processos inventivos e comunicativos.

Você, como desenvolvedor de software que me lê agora, deve à sua profissão se aprimorar em ambos os lados da sua prática, o humano, e o exato. E então poderá se qualificar como um engenheiro.

(Quantas faculdades de engenheria será que expõe os alunos a processos que não tocam somente as ciências exatas, mas tocam também em assuntos como liderança, criatividade, negociação, entre outros? Será que podemos qualificá-las como verdadeiros cursos de engenharia?)


Postado na(s) categoria(s) Arquitetura pelo Giovanni Bassi em 21 de janeiro de 2010 às 15:17 | Tags:

Estou testando o R# com o Visual Studio 2010. Estou trabalhando num exemplo de uma aplicação de ASP.Net MVC com IronRuby pro próximo post, que sai daqui a pouco, e olha a feliz surpresa. Eu tinha este código:

foreach (var itemParaCriar in criarPedido.ItensParaCriar)
{
    var produto = RepositorioProduto.ObterPorId(itemParaCriar.IdProduto);
    var itemPedido = new ItemPedido
                         {
                             Produto = produto,
                             Quantidade = itemParaCriar.Quantidade
                         };
    pedido.Adicionar(itemPedido);
} 

O R# sugeriu uma mudança, algo relacionado com o LINQ. Vejam o resultado:

foreach (var itemPedido in from itemParaCriar in criarPedido.ItensParaCriar
                           let produto = RepositorioProduto.ObterPorId(itemParaCriar.IdProduto)
                           select new ItemPedido
                                      {
                                          Produto = produto, Quantidade = itemParaCriar.Quantidade
                                      })
{
    pedido.Adicionar(itemPedido);
}

Chato né? Ele entendeu que podia trabalhar todo o corpo do foreach dentro de uma expressão LINQ.

A imagem abaixo mostra isso acontecendo (clique para ampliar):

Viva o Resharper! 

Eu já gostava do R#, agora então…


Postado na(s) categoria(s) Visual Studio pelo Giovanni Bassi em 19 de janeiro de 2010 às 17:22 | Tags: ,

Quem é Giovanni Bassi

Giovanni Bassi Sou uma pessoa apaixonada por tecnologia e especificamente por .Net. Sou consultor independente especialista em .Net, focado em arquitetura e melhores práticas. Tenho dezenas de artigos publicados na .Net Magazine, revista da qual sou editor técnico. Ministro palestras e cursos de vez em quando, e quando dá tempo eu respiro um pouco. Mais detalhes nesta página.

Busca

Selos

MVP

MCPD

MCSD

.Net Magazine

Abaixo ao if!

Calendário

«  março 2010  »
seteququsedo
22232425262728
1234567
891011121314
15161718192021
22232425262728
2930311234
Ver detalhamento de posts no calendário

Blogs interessantes

    OPMLDownload OPML file

    Postagens recentes

    Comentários recentes

    Disclaimer / Aviso
    As opiniões colocadas neste blog são minhas e pessoais e não expressam necessariamente as opiniões de meus empregadores, pareceiros e amigos. Da mesma forma, os comentários feitos por leitores do blog não expressam a minha opinião.

    © Copyright 2010 .Net Unplugged
    Log in