Archive for the ‘engenharia’ Category

Chefes e Muros

Sunday, September 5th, 2010

A edição de Novembro da Harvard Business Review traz um artigo muito interessante chamado “The Boss as Human Shield”, que se baseia no novo livro de Bob Sutton, “Good boss, bad boss”. Considerando que Sutton é o autor de No Asshole Rule eu estou bem ansioso para ler seu novo livro.

O artigo me fez lembrar sobre minhas experiências gerenciando times. Eu comecei em empresas pequenas. Nestes lugares minhas responsabilidades incluíam gerenciar pequenos times. Após um hiato trabalhando para empresas grandes eu acabei voltando a “ter meu time ” na Globo.com. Hoje em dia boa parte do que eu faço é gerenciar equipes, incluindo não apenas desenvolvedores mas todas as competências relacionadas ao desenvolvimento de software.

E uma das coisas que eu aprendi é exatamente o que este artigo diz. Para mim, a primeira obrigação de um líder de equipe —ou chefe, ou algo do tipo—é formar uma excelente equipe. A segunda obrigação é deixar este povo trabalhar em paz, sem interrupções desnecessárias.

Quando comecei na Globo.com desenvolvedores no meu time estavam acostumados a comparecer a diversas reuniões por semana. Eram reuniões internas da equipe, com outros departamentos… Naquela época nosso time ficava situado num prédio diferente do resto da empresa, o que fazia com que para cada reunião houvesse um gasto extra de uns 30/40 minutos em deslocamento.

Mudar cultura é algo sempre complicado e eu falhei diversas vezes em conseguir convencer as pessoas de que havia algo muito errado nisso. Existem momentos, entretanto, onde você pode pedir e deve carta branca. No caso do antigo time, esta ocasião foi o lançamento do GloboVideos 4.2, que é basicamente a versão que se encontra no ar ainda hoje, mais de três anos depois daquele projeto.

O time havia passado maus bocados no lançamento do GloboRádio, nosso projeto anterior. Por diversos motivos nós trabalhamos todos os fins-de-semana por um mês e meio. Para o novo projeto eu pedi à gerencia carta branca para tentar algumas coisas diferentes e deixei claro que não me comprometeria com o prazo se tivesse que trabalhar com as limitações do projeto anterior.

O pedido foi aceito e uma das mudanças que implantamos foi uma metodologia mais ágil (a primeira vez que a empresa viu um Story Wall na vida foi a cartolina improvisada que colamos no nosso rack de servidores de desenvolvimento). Uma outra foi ser mais seletivo com reuniões, especialmente reuniões que exigiam o time todo.

Nas primeiras duas semanas do projeto eu pareei com o Tiago Motta desenvolvendo o embrião do framework de widgets que desenvolvemos para o site (que eventualmente virou caso de estudo). Depois de definido um bom rascunho do framework e da nossa API de WebServices eu , praticamente, passei a atuar como porteiro para o time.

A cultura que implantamos nunca foi formalmente definida, mas alguns pontos estavam em nossas cabeças:

  • Nada é segredo, a menos que seja: Ninguém estava proibido de ir a reuniões. Todas as reuniões eram abertas ao time e eu fazia o máximo para explicar ao time o que tinha sido discutido e os impactos.
  • Liderar é basicamente coordenar: Apesar de ser o responsável técnico pelo que era produzido pelo time eu evitava ao máximo tomar qualquer decisão durante as reuniões. Geralmente eu sabia a pauta com antecedência e discutia com o time antes de falar com os outros grupos. Quando eu sabia que teríamos que decidir algo durante a reunião eu trazia o especialista naquela parte comigo.

O grande problema para mim em seguir esta estratégia foi como me manter por dentro da parte técnica. Por gastar tanto tempo em reuniões, quase sempre infrutíferas, eu tinha pouquíssimo tempo para chegar na minha mesa, atualizar meu computador com o código-fonte e dar uma olhada nos commits do dia. Eu tive que investir muito tempo extra para, geralmente em casa, entender onde estávamos e ajudar as pessoas com a visão de para onde queríamos ir. Se pensarmos que este projeto introduziu diversas tecnologias novas na empresa (Memcached, Server-side JavaScript, Widgets, REST…) isso era uma preocupação constante na minha cabeça.

Para o time na era fácil acumular as coisas que queriam conversar comigo para discussão em lotes. Por sorte nós conseguimos montar um time fabuloso antes do projeto iniciar; as pessoas conseguiam, de fato, trabalhar e decidir muita coisa em conjunto e compartilhavam a mesma visão para o produto e a arquitetura.

Essa experiência moldou a forma com que lido com meus times. No início de um desenvolvimento (ou no início do processo de refactoring, caso o trabalho que esteja fazendo seja a recuperação de um projeto que está indo mal) eu passo a maioria do tempo escrevendo código e lidando com problemas técnicos. Depois de algum tempo, talvez uma ou duas iterações, eu passo a dedicar a maior parte do tempo à não deixar desenvolvedores (e testadores, e analistas, e etc.) desperdiçarem o deles em coisas sem valor real.

Isto é central à maneira como eu vejo liderança em times de desenvolvimento. O primeiro problema que, como líder, me preocupo é o ciclo de feedback imediato, as coisas que fazem com que o desenvolvedor perca tempo para escrever código. Com este problema remediado –geralmente seguindo uma destas estratégias– eu passo a focar mais no próximo ciclo de feedback, e no próximo… Estes ciclos foram melhor explicados
na minha apresentação do Caelum Day 2009.

É duro para alguém que gosta do que faz pensar que liderar uma equipe de desenvolvedores significa ter pouco tempo para escrever código mas, no final, o que você precisa ter na cabeça é que é há muito mais valor em capacitar o seu time do que em qualquer peça de código que você consiga escrever sozinho.

Minhas Propostas para a Agile Brazil 2010

Saturday, February 27th, 2010

Acabo de submeter algumas atividades para o Agile Brazil 2010, evento que se realizará em Junho em Porto Alegre. Pelo que entendi, as propostas serão avaliadas pelo comitê organizador do evento.

As propostas estão disponíveis no site e o público pode fazer comentários. Minhas submissões:

Líder Técnico - O Ex-Arquiteto virou Faz-Tudo!

Ele era o centro das atenções. Nenhuma classe era criada sem a sua aprovação. Nenhuma biblioteca era introduzida sem que ele homologasse. Nada entrava ou saía sem a sua verificação. Seus diagramas formavam o livro sagrado do sistema, se o sistema não reflete o diagrama então os desenvolvedores devem ser punidos, obviamente eles não entender seu Grande Plano para Tudo™.

E daí veio este tal de agile. Não apenas introduziu práticas de qualidade duvidosa (duas pessoas, um computador? Sério?) mas também quer eliminar seu papel de visionário. Como um time poderia funcionar sem a visão inpiradora? Como um mero desenvolvedor pode decidir o que é melhor para um projeto onde são investidos milhões?

Pior ainda, o que o líder faz agora que não existem mais diagramas para desenhar?

Arrumando a Casa Após a Festa: Saindo do Pseudo-Agile

Tudo parecia muito simples. Os cartões vão na parede, os times se auto-gerenciam, o tal do Product Owner escreve nos cartões, o time faz retrospectiva… Tantos casos de sucesso por aí, tantos sorrisos e tapinhas nas costas…

Por que está dando tão errado aqui? Por que está fazendo da minha vida um inferno? Por que meu time não está aumentou a produtividade? Por que meus produtos continuam sendo uma porcaria? Por que parece que ninguém sabe o que está acontecendo?

Este é o saco de dúvidas que tenho encontrado por aí.

A maioria vai achar que basta seguirmos os 12 passos do programa e, eventualmente, as coisas vão entrar nos eixos. A maioria acha que basta demitir os gerentes de projeto e colocar coisas coloridas na parede. A maioria acha que basta escrever testes e seu código vai ter qualidade. A maioria acha que basta quebrar casos de uso em histórias e você terá melhor comunicação.

A maioria vai falhar miseravelmente.

Nos últimos anos tenho gasto uma boa parte do meu tempo tentando fazer clientes entender que não importa a cor do cartão na parede, não importa a sua plataforma de desenvolvimento, não importa se você usa cruise ou hudson, não importa se retrospectivas são quinzenais ou mensais… a única coisa que importa nesses tais métodos ágeis é termos ciclos de feedback curto.

Nesta sessão vamos conversar sobre alguns cenários, todos baseados em projetos reais, e no que pode ser feito para tirar o pseudo do seu agile.

E, além das duas palestras, o Rodrigo Yoshima me convidou para ajudá-lo no seu workshop de modelagem:

Reconheça! Você não sabe modelar! Iniciando Projetos Ágeis

Neste workshop prático vamos simular o planejamento inicial de um projeto ágil utilizando as mais variadas técnicas de modelagem como Domain-Driven Design, CRC Cards, User Stories, Paper Prototyping e Brainstorming.

Ajude o cliente a compreender melhor o problema, melhorando seu planejamento e auxiliando as suas estimativas. Um bom modelo ou protótipo serve como uma simplificação de algo complexo, uma abstração útil para o desenvolvimento do projeto. Em projetos ágeis a modelagem está presente, porém, ao invés de uma modelagem solitária numa ferramenta UML, equipes ágeis inovam em colaboração, usando artefatos simples numa dinâmica divertida.

Domain-Driven Bolovo, Passando Conhecimento e etc.

Monday, January 18th, 2010

Segue uma seqüência aleatória quase coesa de pensamentos que me vieram a cabeça enquanto esperava meu vôo para Salvador.

Paulo Silveira surgiu com o termo BOLOVO, usado para indicar uma arquitetura baseada em VOs e BOs, enquanto preparávamos os slides para nossa apresentação em conjunto no JustJava em 2007.

O artigo original sobre BOs e VOs fala basicamente sobre como a arquitetura proposta por EJBs na especificação antiga (2.x) prejudicou o entendimento da comunidade em geral sobre como criar a aquitetura de uma aplicação.

Três anos se passaram mas o artigo ainda recebe um numero de acessos razoável –e eu vivo prometendo que vou atualizá-lo. A última vez que tive que escrever um EJB 2.x foi em 2007, desde então –talvez por sorte- nunca mais entrei em um projeto que usasse estas aberrações. Muitos programadores de hoje em dia começaram suas carreiras na época que EJB já estava morrendo e nunca tiveram o desprazer de lidar com esta porcaria. É de se esperar que estas pessoas, tendo estado sempre cercado por IoC, DDD e técnicas bem razoáveis, iria olhar para um artigo como o que escrevi da mesma forma que eu olho para um livro de linguagem de máquina para Apple II –interessante no contexto histórico mas quase que apenas uma curiosidade.

Vira e mexe, entretanto, eu sou lembrado do porque o artigo ainda recebe tantas visitas todo dia. Os programadores mais novos podem não ter sido influenciados pelos problemas dos EJBs mas ele ainda foram ensinados à programar de uma só maneira: código procedural.

Quando estava preparando a primeira iteração do workshop de Domain-Driven Design que faço em parceria com a Caelum eu escrevi um texto para explicitar meu raciocínio sobre como Domain-Driven Design se difere de Orientação a Objetos. No workshop em si eu dediquei boa parte da manhã falando sobre este tema.

E por quê? Porque da mesma maneira que as pessoas utilizavam os conceitos de EJB completamente fora de contexto o mesmo está acontecendo com Domain-Driven Design. É bem comum, em uma conferencia ou algo do tipo, alguém vir conversar comigo sobre como a empresa dele está eliminando todos os BOs e VOs. No meio da conversa a pessoa começa a me explicar a arquitetura e eu vejo que praticamente o que eles fizeram foi renomear UsuarioBO para UsuarioService e UsuarioVO para Usuario. Repositórios, então… estes são tão mal utilizados que deram origem à vários textos aqui:

Independente do uso de DDD e seus padrões ou não eu realmente esperaria que, em 2010, as pessoas já houvessem entendido como objetos deveriam ser criados. A quantidade de material disponível gratuitamente na Internet e em múltiplos idiomas é ridiculamente grande.

Me levou muito tempo para entender que não importa a quantidade de material disponível. Em minha experiência, a maneira mais eficiente de introduzir estes conceitos é programação em par. Quando um cliente me chama para introduzir estes conceitos em seu time eu sempre tenho que tentar explicar porque isso não pode ser apenas um treinamento. Ë difícil de entender porque eu posso treinar alguém em algo complexo como uma linguagem de programação mas não em uma técnica com mais de 40 anos que exige como pré-requisito nada mais que conceitos lógicos básicos. Eu, pessoalmente, não faço a menor idéia do porque as coisas são assim, só sei que o são.

Normalmente eu começo o trabalho com uma apresentação rápida, apenas para tentar fazer as pessoas entenderem o que diabos eu vou tentar fazer. Um exemplo de uma destas apresentações:

E logo depois começamos a parear. O ideal é termos pelo menos 1 coach para cada dois pares, mas nem sempre este número é viável. Quando a quantidade de pessoas exceed muito a quantidade de coachs a melhor solução parece ser pareamento promíscuo, mudando os pares em intervalos bem curtos de tempo.

Nestes últimos anos eu tive diversas oportunidades de reencontrar clientes e parceiros depois da conclusão do projeto ou treinamento. Na minha experiência os times que tiveram apenas treinamento retêm apenas uma ou outra coisa do todo, eles entendem o todo mas não conseguem aplicar na prática –e aí mora o perigo do Domain-Driven BOLOVO. Os times onde utilizei coaching como meio de transmissão de conhecimento tendem a ser o contrario: eles usam as técnicas no dia-a-dia mas não entendem o todo. Ao não entender o todo eles não conseguem evoluir alem do que o que lhes foi passado durante aquele período.

É de se esperar que o primeiro grupo seja mais valioso para um empregador. Na prática, entretanto, não parece ser o caso. Um treinamento, um livro, etc. podem curar a deficiência do segundo grupo e tendem a ser bem mais baratos e eficientes que gastar dinheiro com um consultor que cobra por hora. O grande benefício que o consultor vai te trazer é que ele sabe –ou deveria- como utilizar aqueles conceitos na prática. O melhor uso do consultor neste caso é trabalhar com o time no dia-a-dia e realizar pequenas sessões de treinamento –no meu caso geralmente isso significa 20 minutos por semana- conforme necessário.

Preparações e Desculpas Esfarrapadas

Monday, October 26th, 2009

Para variar, a desculpa para não ter escrito mais frequentemente é a preparação requerida para a viagem ao Brasil. Eu sei que é uma desculpa esfarrapada mas infelizmente esta etapa envolve mais do que fechar malas e comprar canguru de pelúcia para as sobrinhas, meus últimos dois projetos requereram muita atenção e neste exato momento eu estou finalizando os últimos detalhes de um deles.

Isso fez com que meus planos se alterassem um pouco. Infelizmente não vou ter tanto tempo quanto gostaria para encontrar pessoas, especialmente fora do Rio. Ainda vou em alguns lugares mas nada perto do que tinha em mente antes.

Sobre o evento, acho difícil haver alguém que ainda não tenha esbarrado com um dos banners ou coisa parecida sobre o Caelum Day. A programação está bem interessante e promete ser um dia útil e divertido.

Minha apresentação vai focar no que eu mais tenho feito nestes últimos dois anos: fazer com que times de desenvolvimento saiam do marasmo e comecem a entregar. Não me venha com essa história de “minha metodologia não deixa”, “meu chefe é mau”, etc., todo lugar tem problemas e as coisas dependem de você. A apresentação possui dicas e fundamentos técnicos mas sem vontade nada vai pra frente.

E para, refletir de maneira bem realista o clima da indústria de desenvolvimento de software, este ano eu escolhi mais uma vez filmes de terror para servir de pano de fundo (e comic relief). Ao contrário do ano passado, entretanto, eu escolhi um filme em específico. O primeiro comentário quem acertar o filme baseado na capa da apresentação abaixo ganha… algo… que eu ainda vou decidir:

caelum rio day

As inscrições ainda estão abertas aqui.

Para o workshop de Domain-Driven Design não há mais vagas –mas existe uma lista de espera.

Algumas pessoas ficaram curiosas porque escrevi no meu blog em inglês que acho o assunto (DDD) tedioso. Existe uma enorme demanda de cursos sobre o tema e o Paulo Silveira e eu decimnos que valia a pena realizar mais uma rodada dos cursos. Eu continuo usando Domain-Driven Design em meus projetos e textos, mas o assunto já está meio batido e mastigado.

Na minha opinião, DDD deveria ser parte de um curso maior sobre design em geral, um workshop específico tem relevância quando o assunto é novidade mas perde o apelo quando a técnica começa a ser utilizada por mais gente. Tenho lido mais sobre outras coisas e, se tudo der certo, vamos ver se em 2010 eu consigo aposentar o workshop de DDD e partir para estas novas coisas.

Bom, por enquanto é isso. Nos vemos semana que vem.

Refletindo sobre Tendências

Friday, July 10th, 2009

Recentemente muita gente tem me procurado nos instant messengers da vida para perguntar sobre tendências. Existe uma idéia no Brasil de que quem está de for a “traz as novidades”. Isso podia ser verdade antes da Internet mas agora as coisas se espalham com tanta velocidade que em muitos aspectos o Brasil está muito na frente da Austrália.

Mas existe o outro lado que é o trabalho na ThoughtWorks. Os projetos que nós enfrentamos geralmente começam da mesma maneira que os que qualquer consultoria, de três letrinhas ou três pessoas, enfrenta. O diferencial que faz ser um lugar interessante para se trabalhar é o que acontece durante o projeto.

O que segue neste post é uma amarrado de impressões pessoais sobre os últimos doze meses, tanto sobre a Austrália quanto o que sei de outros escritórios. Se ele não for coeso ou fácil de ler eu peço desculpas mas encare como um braindump.

Os projetos para bancos e empresas do mercado financeiro em geral continuam bem parecidos. Em 2007 houve uma euforia em torno da bolha econômica e muitos projetos megalomaníacos –e, por conseqüência, extremamente interessantes do ponto de vista técnico- apareceram mas a crise os tirou do baralho nos tempos recentes. Os bancos estão gastando menos e buscando fazer mais dinheiro reutilizando a estrutura existente. A maioria dos projetos que eu tenho conhecimento dentro de bancos é para estender uma determinada oferta para novos clientes ou é para migrar de uma plataforma legada para algo menos dispendioso.

O interessante sobre o “legado dispendioso”, dentro e fora de bancos, é que muitas vezes ele se trata de coisinhas como WebSphere, Aqualogic, Biztalk, Tibco e produtos parecidos. Apos gastar rios de dinheiro implantando estes e não ver nenhum centavo de retorno real muitos dos grandes estão migrando para plataformas mais eficientes, quase sempre baseadas em software livre. Hoje em dia são comuns projetos de migração de Websphere para Jetty ou de BizTalk para serviços RESTful usando IIS, JSON e ASP.Net MVC, por exemplo.

Na parte de aplicações para Internet, onde geralmente eu me envolvo mais, as coisas também têm mudado bastante. Basicamente os projetos têm se dividido em startups e legado. As startups aparecem com um problema e algum montante de dinheiro. A plataforma mais utilizada para atender estes cenários é Ruby on Rails, geralmente fazendo deployment em algum serviço de Cloud Computing.

Cloud Computing é um tópico extremamente relevante tanto para ThoughtWorks quanto nos nossos clientes. Uma das coisas interessantes que fizemos no início do ano foi trabalhar junto com o Google no lançamento da AppEngine em Java (e outras linguagens).

As empresas com legado de Internet são sempre interessantes. Geralmente elas são algum grande prestador de serviço na área de mídia e possuem um ou mais websites antigos que têm aquela arquitetura manjada de rodar em um Weblogic ou Tomcat com um Apache de front-end. O problema é que hoje em dia o numero de usuários é muito superior e a velocidade com que funcionalidades têm que ser adicionadas e alteradas é muito maior. Após entender que os Googles e Facebooks da vida não usam Java EE e não pagam licença para a IBM as empresas estão desesperadas para atingir o mesmo nível de eficiência.

O que temos feito nesta área é utilizar a já citada Cloud Computing para realizar tarefas que não precisam ser executadas dentro do firewall (de crawling até rodar teste de carga), refatorar aplicações grandes para atingir escalabilidade horizontal e simplificar processos de deployment e gerenciamento de recursos.

Na área mais de programação em si as coisas não têm sido lá muito excitantes. As plataformas em específico não têm nenhuma novidade marcante mas a programação poliglota é uma realidade. Até hoje todos os projetos que tive alguma participação dentro da ThoughtWorks utilizavam mais de uma linguagem de programação (já descontando Bash e JavaScript).

Uma surpresa agradável foi a que tive no meu projeto atual, em que voltei a programar em .Net após 3 anos afastado. A maioria das coisas que eu realmente não gostava sobre C# e seu ecossistema foram removidos (exceto Windows e Visual Studio, duas peças que eu considero de qualidade inferior). A Microsoft continua enfiando frameworks e ferramentas terríveis pela guela dos seus clientes (MSBuild? TFS? WCF? WTF?!?) mas no geral as coisas estão bem melhores.

Em termos de livros sobre programação eu tenho me focado quase que exclusivamente nos conceitos presentes em linguagens e paradigmas de programação. Esta é a lista de livros relacionados que eu li desde que cheguei aqui:



Esta é a fila dos que faltam:


(fora os que ainda estão no meu carrinho de compras na Amazon. Livro na Austrália é ridiculamente caro)

Na parte de gerenciamento de projetos e metodologias as coisas estão engraçadas. Tem horas que a euforia anima, tem hora que dá náusea. Eu acho que o Bellware resumiu muito bem:

early agile adopters were looking for a way to do things better. later adopters are just trying to do agile, thus the failures

Eu vim para a ThoughtWorks para ver como é que quem introduz métodos ágeis há anos trabalha. Nos últimos meses eu trabalhei com pessoas que fazem isto há mais de dez anos e em empresas que adotaram agile antes de eu saber que ele existia. O que eu aprendi neste período inicial é exatamente o descrito acima: quando seu objetivo é ser ágil você falha, quando seu objetivo é sempre melhorar você tem chances de sucesso.

Todos os projetos que participei foram bem sucedidos? Depende de para quem você pergunta. Mesmo os clientes mais difíceis que tive acabaram ficando satisfeitos no final mas muitos projetos que participei (e o número de projetos é bem maior que o número de clientes) foram executados de uma maneira que o time não ficou satisfeito. Eu acho que neste caso é perspectiva. Como a maioria dos projetos são um fracasso colossal basta ter algum nível de sucesso que o projeto vira referência. O time, em compensação, tem um critério de sucesso muito mais alto e não considera o projeto como bem-sucedido.

É claro que no fim das contas o que vale mais é a opinião do cliente –tanto porque o problema dele foi solucionado bem como porque é ele quem paga a conta no final- mas eu já vi diversos problemas decorrentes deste tipo de coisa. De builds que começaram em 10 minutos e terminaram em duas horas de duração até um time que perde 50% do seu tempo corrigindo defeitos por falta de uma suíte de testes decente. Os problemas podem não ser grandes para aquele projeto em específico mas não prestar atenção há eles é mortal em médio prazo.

Minha conclusão é que a indústria está num estado melhor do que há alguns anos atrás. Tecnicamente estamos entrando em uma espécie de renascimento e isso promete render muito material para posts aqui. Em termos de gerencia de projetos e processos as pessoas estão finalmente se convencendo que tudo tem limite, até ineficiência.

Mingle Day - Rio e São Paulo

Tuesday, June 23rd, 2009

Como este blog já anunciou este ano será cheio de eventos da ThoughtWorks no Brasil.

Uma coisa a se notar sobre a ThoughtWorks é que somos uma empresa de consultoria mas com uma divisão de produtos. Como a eventual vinda da ThoughtWorks para o Brasil significa a vinda das duas partes é bom que também apresentemos ao mercado brasileiro os softwares que produzimos.

O software mais popular da suite é o Mingle, um sistema de gerenciamento de projetos com muitas características interessantes. Ele foi construído baseado na experiência da empresa prestando consultoria, entende bem que cada processo é diferente e que modelos engessados não funcionam bem. Também possui uma interface rica que aliada com alguns recursos de hardware se torna uma ferramenta extremamente útil quando um Kanban eletrônico é necessário. Por fim é provavelmente o mais famoso caso de uso do JRuby on Rails -o Mingle usa componentes escritos em Java aliados aos recursos do Rails.

Se você quer conhecer mais sobre o produto tem duas oportunidades. Abaixo os convites.

Rio de Janeiro

Hi,

ThoughtWorks is sponsoring Agile Brazil 2009, the first major conference on Agile methodologies to be held in Rio de Janeiro, Brazil. In this extensive, one-day event, various practitioners and speakers will conduct sessions on a range of well-known Agile methodologies and practices such as Lean, Scrum, XP, User Stories, Continuous Integration, Release management and Test Driven Development.

Date and Venue:
June 27, 2009, 8:30am - 6:00pm.
Salao A (Padre Anchieta hall)
PUC-Rio, Gavea, Rio de Janeiro, Brazil.
Registration Information
Registration: R$ 200,00.
Register for Agile Brazil 2009

Mingle User Group Meeting in Rio de Janeiro

We have organized a free follow-on event for agile enthusiasts. We invite you to the Rio Mingle User Group (MUG) Meeting, an exclusive meet for Mingle users in Brazil, to discuss and share their experience with Mingle. Adam Monago, our product expert along with other Agile experts will take you through Mingle and its features and provide you tips and tricks on how to better use Mingle for project management and collaboration. After the talk you can interact with the attendees over food and drinks.

Date: 1- July-2009
Time: 17:30 - 19:00
Venue: PUC-Rio, Rua Marques de Sao Vicente 225 - Predio Padre Leonel Franca - 13 andar - Gavea, Rio de Janeiro, Brazil

To confirm your participation for the Mingle User Group, simply reply to this email: Studios-Brazil@thoughtworks.com?

Regards,
ThoughtWorks Studios
Studios-Brazil@thoughtworks.com

São Paulo

A Aspercom e a ThoughtWorks convidam você para o Encontro Agile / Mingle User Group Meeting. Este será um evento gratuito em São Paulo com mini-palestras, discussões e muito bate-papo.

Data: 30 de junho de 2009 às 19:00hs / Local: Av. Paulista

Facilitadores:
Paulo Caroli, Adam Monago (ThoughtWorks)
Rodrigo Yoshima, José Paulo Papo

Mingle User Group Meeting

O encontro do Mingle User Group (MUG) do Brasil é uma oportunidade para conhecer, discutir e compartilhar experiências com o Mingle. Adam Monago, um especialista no produto juntamente com outros Agilistas experientes, demonstrarão o Mingle provendo dicas e truques em como usar o produto para gerenciamento de projetos e colaboração.

Local, agenda, inscrições e outras informações acesse: http://blog.aspercom.com.br/2009/06/22/evento-agile-mingle/

Rodrigo Yoshima
ASPERCOM

Paulo Caroli
ThoughtWorks

Não Vai Subir Ninguém!

Tuesday, December 9th, 2008

A coisa mais comum em uma empresa é a formação de uma “tropa de elite”, contendo os principais e provavelmente mais talentosos desenvolvedores. O raciocíno é simples. Empresas em geral são uma bagunça tecnicamente, anos e anos contratando desenvolvedores sem muito critério (e não investindo nos mesmos após contratação) fez com que sejam criados sistemas que não se falam, projetos que atrasam, duplicação de esforço além dos odiosos bugs em produção que te acordam na hora em que eu estou almoçando aqui em Oz.

E é claro que as consequências são desastrosas. Não houve uma só grande empresa onde (ou para quem) eu tenha trabalhado onde não existe a elite da tropa. São aqueles technical stakeholders pessoas para quem você bate continência e tem que agradar. São aquelas pessoas que não estão envolvidas com seu projeto mas ainda assim podem acabar com ele. São parte daquele grupinho que age como a polícia e defende a “moral e bons costumes”, matando a inovação no caminho. São aqueles que estampam seu projeto com o “selo de qualidade”, onde qualidade significa concordar com eles.

Lembranças dolorosas não faltam. Certa vez eu cheguei em um projeto muito perto da ida para o ar. A estrela dentre as funcionalidades era um sistema meio estranho que categorizava conteúdo, mas como eu era novo no time deixei para lá e fui resolver os bugs que impediam o release. Na véspera do release nós percebemos que o sistema “estranho” não aguentava nem um terço dos acessos que teríamos.

O líder de desenvolvimento daquele sistema foi extremamente contra qualquer mudança no mesmo. Ele havia sido desenvolvido de acordo com os critérios passados pelo grupo de arquitetura da empresa e o arquiteto havia solicitado uma solução genérica que pudesse ser reutilizada em todos os mais de 100 produtos da empresa.

Um requisito mais que válido. Reinventar aquilo cem vezes seria um desperdício sem tamanho. Mas o projeto deveria ser entregue em alguns meses e desenvolver aquela funcionalidade “pensando no bem da nação” o fez não só atrasar e custar noites em claro bem como resultou em um sistema que sequer atendia o projeto em questão, muito menos todos os outros 99 sistemas.

O problema é que o arquiteto não fazia parte daquela equipe e não entendia seus requisitos e características. Não estava presente no desenvolvimento, não escreveu uma linha de código, não tinha comprometimento com a entrega.

Não importa o quão bom o time seja, conhecimento técnico só tem valor dentro de um contexto e neste caso o contexto é um time ou um projeto. A falta de comprometimento e de “senso de time” faz com que a “tropa de elite” seja vista mais como uma dificuldade a passar do que algo que traz auxílio. Eu não tenho idéia de quanta vezes tive que adicionar e remover caixinhas em diagramas só para agradar alguém que senta em uma torre de marfim e desce apenas para chicotear os incautos.

E em médio prazo as coisas pioram. Um fato claro é que o grupo se fecha: ninguém dos reles desenvolvedores é bom o suficiente para subir para a elite. Os desenvolvedores com potencial acabam saindo da empresa porque são tão cortados pelo time de elite que desistem e vão tentar ser arquitetos em outro lugar. A falta de abertura, o medo que os desenvolvedores têm dos “caveiras” e a auto-confiança que o grupo desenvolve (afinal eles não têm que passar por avaliação técnica nenhuma, eles são a verdade!) faz com que opiniões se tornem leis.

Recentemente eu tive um caso engraçado. Estávamos introduzindo serviços REST em uma empresa e uma das barreiras era este tipo de time. Eles eram os melhores desenvolvedores da empresa, ditavam as leis e odiavam qualquer coisa que lembrasse processamento remoto. Meu então chefe, um excelente técnico mas com uma capacidade acima do normal de perder a cabeça, e eu marcamos uma reunião com este time para apresentar a idéia.

Durante a semana anterior eu fiquei polindo slides e buscando referências para responder qualquer dúvida técnica. No dia da reunião eu estava extremamente nervoso e após 15 minutos de atraso meu chefe saiu da sala para ver porque os arquitetos não haviam chegado ainda. Eu aproveitei os minutinhos para dar uma última revisão quando comecei a ouvir gritos do lado de fora. Ao sair dei de cara com meu chefe e o arquiteto sênior discutindo calorosamente a questão dos serviços.

O arquiteto master argumentava que eles já tentaram EJB e deu errado, já tentaram WS/SOAP e deu errado e que ninguém vai usar mais serviço nenhum. Isso não funciona nesta empresa, já vimos isso e ponto final. Vendo que aquilo não ia ajudar muito eu puxei meu chefe pelo braço e voltamos para o escritório.

Não havia como desistir da tecnologia nem do projeto, então marcamos uma segunda reunião. Desta vez eu mudei todos os slides e fiz questão de não convidar meu chefe. Eu removi todos os slides que falavam de REST e a palavra “serviço”, deixei apenas o HTTP. A reunião foi ótima, o sistema estava abençoado pelo arquiteto master e podíamos seguir em frente. Qual o valor que estas duas reuniões e duas semanas de trabalho trouxeram? Elas alimentaram o ego do arquiteto, ele realmente acreditou que nós mudamos a arquitetura para o agradar. Só isso.

Este tipo de barreira cria medo entre os desenvolvedores. Ainda que você tenha uma excelente idéia para aquele seu projeto vai ter que justificar para aquela pessoa que não quer nada além de arrumar algo que justiique seu cargo. A inovação morre em meio ao medo de propôr algo e ser rechaçado.

É impressionante como este padrão de organização departamental lembra a história da humanidade. Um grupo é oprimido por um governo corrupto e injusto. O grupo é exilado (i.e. pede demissão) une forças, volta e derruba o governo. No próximo passo o grupo forma seu próprio governo, corrupto e injusto como o anterior.

Mas o que fazer? Como falei no início, as empresas são uma zona! É comum que a cada 100, 200 desenvolvedores tenhamos meia dúzia que está acima da média. A solução me parece óbvia: não concentre, distribua.

Se você tem poucos bons desenvolvedores não faz o menor sentido agrupá-los, pelo contrário! Espalhe os desenvolvedores bons entre os times e certifique-se que eles possuem autoridade suficiente para mudar as coisas. Treine seus desenvolvedores como coaches e os faça ocupar o papel de líder técnico em projetos. Crie um programa de mentoria de desenvolvedores e faça com que seus jovens talentos tenham como referencial os melhores.

E como controlar este tipo de atividade por toda a empresa? Crie comunidades de prática. Ao invés de um “departamento” de arquitetura ou de “práticas de desenvolvimento” crie uma comunidade que abrange diversos departamentos e times. Em vê de investir um bolo de dinheiro em um grupo de pessoas invista um pouquinho em cada um dos seus times, deixe eles realizarem atividades para melhorar suas habilidade durante o expediente. Em vez de criar xerifes e a cultura do medo crie uma cultura de melhoria contínua, remova as maçãs podres da sua empresa e crie mecanismos para acompanhar o desenvolvimento de todos os membros do time.

Domain-Driven Design & Agile: Fechando Malas

Wednesday, October 8th, 2008

Como falei algumas dezenas de vezes estou no fim de um projeto, na verdade na minha última semana neste instante. Foi um projeto muito interessante onde pudemos aplicar diversas técnicas como Domain-Specific Languages para testes e promoção de testes de aceitação. Também foi o primeiro projeto Java sem container que participei desde 2006, apenas PicoContainer, Hibernate, JMX e um cliente JMS -sem mesmo interface de usuário.

Outro ponto interessante sobre este projeto é que foi uma reescrita de um sistema com o qual estive envolvido antes. O cliente está passando por um programa que compreende diversos projetos e muitas fases. Há alguns meses nós fomos chamados para entregar, em algumas poucas semanas, uma versão deste sistema. Na nova fase do projeto eles resolveram investir mais na qualidade deste e tivemos uns bons 3 meses para reescrever tudo. Não só o sistema foi completamente reescrito bem como teve um time diferente (no anterior erámos eu e um colega ThoughtWorker, no atual somos 5 pares entre TWers, empregados do cliente e outros terceirizados).

O problema agora é a pressa. Não, o projeto não está com pressa, nossa entrega é em uma semana e faltam poucos cartões na parede. Eu que estou. Estou saindo deste projeto com muita coisa que eu queria fazer ainda meio-acabada e nesta última semana estou me dedicando basicamente a criar tracing bullets para o desenvolvimento futuro já que quem toma conta do sistema a partir da entrega de 15/10 é o cliente. Não é fácil com tão pouco tempo.

E esta lenga-lenga foi um mea-culpa para maiores informações sobre minha viagem ao Brasil. O press-release ficou assim:

Dia 23 e 24 de outubro ocorre em São Paulo o primeiro grande evento de Agile do Brasil:
http://www.falandoEmAgile.com.br/

Ouça as histórias de empresas que tem obtido sucesso com Scrum, entenda como estas práticas podem ser implantadas em ambientes tradicionais de projetos, veja o que a indústria tem falado e feito com Agile e descubra quais serão os próximos passos a serem dados nesse mundo. Conta com o palestrante internacional David Anderson, reconhecido líder na comunidade Ágil e autor do livro “Agile Management for Software Engineering”, e com o primeiro Certified Scrum Trainer da Scrum Alliance da América Latina, Alexandre Magno. De tópicos de Scrum e CMMI até estudos de caso com Agile na Austália, Inglaterra, Estados Unidos e Brasil.

Ocorrerão mais outros eventos próximos a essas datas:

O Zen of Agile, nos dias 21 e 22, um workshop com David Anderson:
http://www.heptagon.com.br/ws-zen-agile-mgmt

O Certified ScrumMaster, dias 27 e 28 de outubro:
http://www.caelum.com.br/treinamentos/csm-certified-scrum-master/

E por três vezes Phillip Calçado, conhecido aqui no GUJ, ministrará um workshop de Domain Driven Design de 8 horas, dia 21 de outubro no Rio de Janeiro, e dias 27 e 28 em São Paulo:
http://www.caelum.com.br/treinamentos/ws-46-domain-driven-design/
http://philcalcado.com/2008/09/01/brazilian…em-agile-domain-driven-design/

Está sendo divertido montar este workshop. É algo estranho porque é maior que uma palestra e menor que um curso -ao mesmo tempo é tempo demais e tempo de menos. Eu quero começar desmistificando alguns conceitos sobre objetos, trabalhando a idéia das decisões em três níveis e só depois entrar em Domain-Driven Design. É impressionante como fica mais claro falar sobre DDD depois de quebrar mitos, numa palestra nunca se tem tempo de fazer isso.

Como falei antes, para maiores informações basta ligar para a Caelum do Rio ou São Paulo.

E com a confirmação das datas eu muito provavelmente vou estar também no último dia do Rails Summit.

Brazilian Tour 2008: Falando em Agile, Domain-Driven Design

Monday, September 1st, 2008

Outubro vai ser um mês bem interessante. Vou entregar um dos meus projetos mais importantes até agora (pelo menos é o que nossas previsões dizem) e vou passar 15 dias entre férias e eventos no Brasil.

O motivo principal é para realizar uma apresentação no Falando em Agile 2008, mais um evento da Caelum. As inscrições estão abertas e inscrevendo-se com antecedência você consegue desconto.

Minha palestra vai ser sobre um tema que venho desenvolvendo há algum tempo: como adoções ágeis que tinham tudo para dar certo afundam. Antes de entrar para a ThoughtWorks eu já tinha vivido esta situação pelo menos duas vezes, nestes nove meses trabalhando numa grande consultoria especializada eu já vi umas três. Todas tinham um grupo de sintomas bem parecidos o quais estou tentando estruturar. Não é lá muito fácil mas acho que o resultado tende a ser bom. Se você acha que Vovô viu a uva, a web somos nozes, arquitetura BOLOVO e amigos foram piadas infames e de mau-gosto mal podem esperar pela temática desta apresentação…

Uma das coisas mais interessantes sobre o FalandoEmAgile 2008 para mim vai ser a presença do Danilo Bardusco na grade. O Danilo foi meu gerente na Globo.com antes de assumir tudo-menos-webmedia, quando passei a responder diretamente ao Antônio Carlos. Naquele momento a empresa viva diversas histórias tristes com métodos baseados em Waterfall, micro-management e consultorias CMMI 5; apesar dele não acreditar que aquilo ia dar certo no início foi sua perseverança e abertura à inovação que possibilitou aquele trabalho inicial que hoje, graças ao trabalho de todos, é referencia. O grande defeito dele é aquela mania infeliz de usar Vi quando todo mundo sabe que emacs é o único editor de texto que deveria ser utilizado. Mas eu perdôo.

Como falei, são 15 dias no Brasil. Eu ainda não sei as datas do que vou fazer mas devo ter algumas outras apresentações de palestras no Rio (certamente no RioJUG) e em São Paulo.

Como eu já estava vindo para o Brasil, acabei fechando com a Caelum uma série de oficinas em Domain-Driven Design. A idéia é cobrir os principais aspectos desta filosofia de design de uma maneira descontraída mas substancial. O primeiro post que menciona Domain-Driven Design neste blog é de 2005, e foi importado do meu antigo blog no blogger.com. Nesta época quase ninguém havia ouvido falar do conceito. Hoje ainda é algo relativamente obscuro mas um pouco mais popular. Claro que com a popularidade vem os problemas. Muita gente no GUJ, em blogs e outros fóruns está simplesmente associando Domain-Driven Design com um bom design Orientado a Objetos, ou pior ainda: com qualquer design OO.

Ao contrario do recente mito popular, Domain-Driven Design não é “voltar para Orientação a Objetos”. Orientação a Objetos foi criada como uma maneira de gerenciar dependências e criar unidades coesas e atômicas de código, não necessariamente uma forma de modelar uma Camada de Negócios. O que Domain-Driven-Design traz de volta é a possibilidade de utilizar as vantagens da Orientação a Objetos para criamos um modelo que reflita o mundo real de maneira mais íntima. Você não precisa sequer de objetos para aplicar o coração de Domain-Driven Design, ou mesmo seus Patterns.

A parte do “substancial” que falei acima é exatamente esta: não misturar Orientação a Objetos com Domain-Driven Design e sim trabalhar a relação entre eles. A parte “descontraída” é na forma de passar este conhecimento. Após alguns anos ministrando treinamentos eu não tenho a fórmula ideal para passar este tipo de conteúdo (altamente abstrato e que requer conhecimento posterior) mas eu já aprendi por tentativa e erro diversas formas em que isso não dá certo –pelo menos não comigo. Duas delas são: aulas expositivas e laboratórios. Se você não entende porque aulas expositivas não servem para este tipo de coisa pense sobre todo o conteúdo que é quase que literalmente jogado em cima de alguém numa faculdade e quanto dele é entendido (e entender não é tirar 10 na prova). O problema de laboratórios é que sempre perde-se tempo com a máquina, ou a linguagem (este não é um workshop Java ou Ruby ou C#, é um workshop sobre objetos).

Eu não tenho as datas nem preços (já encheu o saco da Caelum hoje?) mas vamos ter sessões em outubro no Rio e São Paulo, a preços acessíveis.

Analista Pedreiro

Saturday, August 9th, 2008

Meu post sobre Análise de Sistemas já teve 65 comentários (incluindo respostas, é claro). Acho que já descartei uns 20 comentários anônimos para este. Nem todos falavam da minha mãe, alguns tinham coisas interessantes mas infelizmente este blog não aprova comentários anônimos, sejam criticas interessantes ou xingamentos.

Esta manhã eu recebi um destes anônimos interessantes e, apesar de não o aprovar, gostaria de comentar trecho deste:

Francamente modelar com o código é o mesmo que fazer um projeto de uma casa com tijolo e cimento.

Este trecho me despertou o interesse porque há algum tempo fiz um experimento e gostaria de convidar vocês para repeti-lo. Como falei em posts anteriores Melbourne, minha cidade atual, é um lugar razoavelmente conhecido por suas boas universidades e centros de pesquisa. Como conheço alguns estudantes de graduação ou recém-formados (A ThoughtWorks possui um programa para contratar graduandos) eu conheci algumas pessoas que lecionam em universidade locais, entre eles uma simpática senhora que ensina disciplinas num curso de arquitetura e edificações local.

O dialogo foi sobre especificações, plantas e modelos.

- Imagine que a senhora pudesse, ao invés de criar um modelo em papel, construir seu projeto incrementalmente. Em dois dias a senhora tem o banheiro pronto, em três dias a varanda.
- Como numa maquete?
- Não, eles estão prontos mesmo. Você pode usar o banheiro, pode dormir no quarto, pode efetivamente utilizar o prédio.
- Mas e se eu precisar mudar algo? Isso iria ficar muito caro.
- Imagine que o custo é apenas o de dois dias de trabalho. Sem custo material. A cada dois dias você termina um pedaço da casa e mudar é tão simples quanto construir.
- Ok. Seria ótimo. Qual seu ponto?
- Isso ainda afaria requerer uma planta baixa, um modelo em papel ou AutoCAD?
- Precisaria porque eu preciso comunicar o projeto aos trabalhadores.
- Ah, sim, claro, mas imagina que construir não seja um trabalho braçal. Você tem, sei lá, robôs que sobem paredes e fazem o trabalho pesado, você só diz qual a dimensão, inclinação, que material, etc. e eles constroem. Você desenha no AutoCAD e os Robôs constroem imediatamente, daí você pode entrar no prédio e se tem algo errado em segundos você conserta. Você pode levar seu cliente para andar no prédio.
- Ok. Mas neste caso você não está eliminando o modelo gráfico.
- Não?
- Não, neste caso você automatizou a construção. O que você fez foi fazer com que o trabalho do arquiteto seja simplificado eliminando o custo da construção. Se qualquer coisa que eu mudar no modelo muda no prédio real imediatamente e sem custo o papel do modelo é ainda mais importante. Você não tem real diferença entre modelo e prédio. Você não tem transformação real entre um e outro. O modelo é o prédio.

Deste ponto eu comecei a explicar para ela como engenharia de software funciona. A conclusão que nós chegamos é que engenheiros de software possuem o poder que falta para engenheiros civis/arquitetos e ainda assim usam as ferramentas de quem não tem este poder.

Arquitetos adorariam modelar com tijolos, paredes e coisas reais. Eles não podem. Nós podemos.