No dia 7 de Agosto de 2010, sábado, acontecerá o Café Ágil em Curitiba realizado pela ThoughtWorks nas dependências das Faculdades Opet. Será uma ótima oportunidade para bater papo de alto nível com o Daniel Wildt e Klaus Wuestefeld, consultores da ThoughtWorks, as palestras abordarão um assunto muito importante mas pouco utilizado na prática, Testes de software e Agilidade.

Lógico, que eu já garanti minha inscrição e estarei lá!

Confira a agenda do evento:

Das 8h30 às 9h, Café e recepção
Das 09h às 10h, Como você está testando seu software? – Daniel Wildt
Das 10h às 11h, Automated Software Testing for Advanced Gurus – Klaus Wuestefeld
Das 11h às 12h, Discussão sobre Agilidade, Testes e Desenvolvimento de software com a platéia.

Como você está testando seu software?

Nesta palestra, venha praticar valores, princípios e técnicas sobre as formas de testar, criando um ambiente que gere transparência e visibilidade sobre o desenvolvimento de Software.
Perguntas que serão discutidas na palestra:

• Que técnicas de teste você utiliza?
• Que ferramentas servem de apoio ao seu processo de teste de software?
• Como você testa as funcionalidades desenvolvidas?
• Como você valida a qualidade do seu código fonte?
• E a auditoria de código como fica?
• Você integra seu software de forma contínua?
• E Test Driven Development, você está utilizando?

Daniel Wildt é consultor da ThoughtWorks Brasil, trabalha com Métodos Ágeis desde 2003, fundou o Grupo de Usuários de Metodologias Ágeis do Rio Grande do Sul em 2004. Um dos organizadores do Agile Brazil 2010. O que é Agilidade? Atitude, foco em entrega de software, trabalho em equipe e mehoria contínua. Mais informações em http://danielwildt.com/

Automated Software Testing for Advanced Gurus

Mocks, Stubs, Signals, Domain Specific Languages (DSLs) para teste, Adapters, injeção de dependências, teste de código concorrente… Está na hora desses conceitos não serem mais mistério para você. Venha ver essas coisas em ação numa apresentação 100% executada em código Java.

Klaus Wuestefeld já trabalhou em par com Kent Beck, Vinicius Teles e Scott Ambler. Participou da primeira conferência internacional de XP, em 2000, na Itália. Realizou os eventos “Extreme Programming Brasil 2002 e 2004″ com a presença de Beck, Ambler, Teles, Tom e Mary Poppendieck, entre outros. É o culpado pelo Prevayler e pelo manifesto da computação soberana. Lidera projetos de desenvolvimento e treinamento em XP para empresas como TV Globo, Siemens, TIM e Banco Central do Brasil.

Faça já sua inscrição aqui: http://www.thoughtworks.com/cafe-agil-em-curitiba

Bem, nesse período tive a oportunidade de palestrar em duas faculdades aqui em Curitiba, UTFPR, no dia 4 de maio de 2010 na VII Semana Acadêmica de Informática da UTFPR,

e Faculdades OPET, no dia 19 de maio de 2010 na Semana Acadêmica de Informática da OPET.

Nas duas oportunidades apresentei a plataforma de desenvolvimento de RIA da Adobe, inclundo algumas novidades do Flex 4 e Flash Builder 4. Ao final da palestra mostrei como é fácil a integração entre o Flex e o PHP, você não leu errado, eu mostrei mesmo a integração entre o Flex e PHP :-D.

Essa palestra é altamente recomendada para quem está chegando hoje ao mundo RIA e quer conhecer um pouco mais sobre as Rich Internet Application e ao novo Adobe Flex 4 e o Adobe Flash builder 4.

Os slides que utilizei nas palestras:

A palestra na OPET, a minha esposa, Fernanda Musardo conseguiu filmar.

Se você é estudante de ensino médio ou de graduação, não perca a chance de aumentar / ou reciclar seus conhecimentos em

As inscrições para o Microsoft Students to Business (S2B) em Curitiba vão até o dia 19 de abril de 2010.

O Programa tem por objetivo aproximar estudantes de oportunidades de trabalho nas carreiras de Tecnologia de Informação.

Para isso inclui diversas ações, sendo as principais capacitações gratuitas nas plataformas Microsoft e aproximação com empresas que buscam mão-de-obra com esse perfil.

O programa tem um total de 84 horas/aula para capacitação de jovens, com um conteúdo que abrange palestras sobre o mercado de trabalho e aulas teóricas e práticas ligadas às carreiras de TI.

As capacitações são voltadas a estudantes do ensino médio e superior e visam preparar as próximas gerações de profissionais nas tecnologias Microsoft.

Ao longo de 3 fases os estudantes adquirem formação técnica para tornarem-se profissionais júnior desenvolvimento. Na primeira fase o curso traz informações sobre as carreiras de TI, na segunda, aulas teóricas e na terceira, aulas práticas, com o desenvolvimento de um projeto de formatura.

No encerramento são entregues certificados, em um evento que inclui uma feira de empregos, uma excelente oportunidade para você que ainda não trabalha ou está querendo trocar de empregador.

O Road Show é um evento presencial diferenciado e parte integrante da campanha Copa de Talentos da Microsoft Brasil.

Todas as sessões são focadas em demonstrações e explicações feitas ao vivo, utilizando um ambiente de demonstração com os últimos lançamentos da Microsoft.

Há apenas uma breve introdução teórica, para entendimento do cenário e depois, o time de Especialistas da Microsoft apresentam ao vivo, na prática, toda a solução sendo implementada passo a passo.

Neste evento será apresentado um caso fictício de uma empresa que possui vários desafios de TI (desenvolvimento de software e infraestrutura de TI), e como os novos produtos e tecnologias da Microsoft podem torna-la mais competitiva, com gerenciamento, segurança, escalabilidade e performance.

Serão abordados novos produtos como Windows Server 2008 R2, Windows 7, Exchange 2010, Visual Studio 2010, SQL Server 2008 R2, Office 2010, Sharepoint 2010, System Center, Forefront, Silverlight, etc.

Você aprenderá como virtualizar seu ambiente, criar ambientes de testes de desenvolvimento, utilizar da melhor forma as soluções de comunicação unificadas, tornar suas aplicações mais ricas além de muitas outras capacidades.

Ao termino do evento você aprenderá como tirar melhor proveito de tais tecnologias, tornando-se um diferencial competitivo.

O Road Show será tanto para desenvolvedores quanto para infra-estrutura.

Inscrição para Desenvolvedores

Inscrição para Infra-Estrutura

Nos encontramos lá!

Data: 06/05/2010 (Quinta-feira)
Horário: 08h00min às 17h30min
Local: Estação Embratel Convention Center (Rua Sete de Setembro, 2775)

Inscrições: R$ 50,00 Clique aqui e faça a sua inscrição.

Nos encontramos lá!

Fique por dentro das novas tecnologias da Microsoft em um evento presencial na cidade Curitiba realizado pelo Centro de Inovação da Microsoft.

Data: 27/03/2010 (Sábado)
Horário: 09h00min às 16h50min
Local: Auditório do Centro Tecnológico da Universidade Positivo (Rua Alf. Ângelo Sampaio,2300)

Inscrições: Clique aqui e faça a sua inscrição. Vagas limitadas!
Entrada: Uma lata de leite em pó.

Confira a programação

Eu já fiz a minha inscrição! Nos encontramos lá!

Troquei muitas idéias, conhecimentos, experiência sobre Adobe Flex e desenvolvimento em geral com esse turma que particularmente sou fã de carterinha!

Vedovelli e sua esposa Ana, que me aguentaram o final de semana inteiro, foram super hospitaleiros e fizeram com que realmente me sentisse em casa.

Passeamos bastante e pude conhecer um pouco mais da cidade da garoa, digo das enchentes, embora eu tenha tirado a sorte grande e não choveu nada nesses dias.

No sábado fomos jantar na Cantina C… Que Sabe no bairro do Bixiga, onde comemos uma lasanha muito saborosa com um chopp refrescante!

Após a lasanha fomos no Bar Asterix onde tomamos Guinness, cerveja tão falada pelo Fábio. E de fato, tem motivo para gostar, porque a danada é gostosa! Foram momentos muito divertidos!

O que na minha opinião foi mais bacana foi que pude conhecer a pessoa por trás do profissional Fábio Vedovelli, e além de fã do trabalho, tornei fã deste cara tão bacana que compartilha seus conhecimentos de maneira única!

Só me resta voltar a agradecer profundamente ao Vedovelli, a Ana, Marcos, Fábio, Sergio e Dinorah por terem me recebido de braços abertos.

Veja o vídeo da minha chegada à Ria Labs.

Para minha total surpresa, o Beck Novaes apareceu na Ria Labs e pude conhecer pessoalmente o mestre dos magos do Flex. Não perdemos tempo e gravamos um vídeo convocando o Carlos Eduardo da E-Genial para ir à São Paulo visitar a Ria Labs também! O Ved mais que depressa postou o vídeo!

Veja como foi nossa intimação ao Carlos.

Enfim! Foi du caramba passar esse final de semana ao lado de pessoas tão especiais!

Muito obrigado por tudo gente e reafirmo aqui no blog o que já disse pessoalmente e no Twitter.

Ved e Ana, estamos esperando vocês aqui em Curitiba! É só chegar! Vlw!

• Visual Studio 2010 Ultimate;
• Visual Studio 2010 Premium;
• Visual Studio 2010 Professional;
• Visual Studio 2010 Remote Debugger;
• Visual Studio 2010 F# 2.0 Runtime;

Todas as instalações estão no formato ISO. Se tiver alguma dúvida como instalar o Visual Studio a partir de uma ISO, acesse esse post o blog do Charles Sterling.

Saiba como remover as versões do Visual Studio .NET Beta e Release Candidate em: http://support.microsoft.com/kb/312383/pt

A partir de agora somente bug das classes serão tratadas para o ASP.NET MVC 2, todo e qualquer bug report será tratado no ASP.NET MVC 3.

Corra, pois a maratona é agora dia 06/fev/2010.

Fazendo sua inscrição você, além de ajudar o Cotolengo, pois essa maratona é beneficiente, você concorrerá ao final do evento à um Magic Mouse da Apple (oferencimento do Fábio Vedovelli) e à um Adobe Flex Builder Pro (oferecimento do meu chará Igor Costa).

A inscrição tem um valor simbólico de R$ 30,00.

Além disso, todas as palestras serão gravadas e estarão disponíveis 15 dias após o evento para todas as pessoas que fizerem sua doação. Por isso, mesmo que você não possa estar on-line agora dia 06/fev/2010, não deixe de fazer sua doação, pois você fará o download de TODAS as palestras e poderá assistí-las quantas vezes quiser.

+ de 320 pessoas já se inscreveram nesta maratona, faça parte você também.

Confira abaixo quais os conteúdos que serão abordados na maratona.

Desenho criado por uma criança da Cotolengo

Durante anos estivemos dedicados ao desenvolvimento de Aplicações Ricas. Durante anos estivemos dedicados a tecnologias como o Adobe Flex, BlazeDS, LiveCycle Data Services, Zend AMF, AMF PHP, Adobe Flash Professional, Flash Media Server, etc. Mas, principalmente, durante anos estivemos dedicados a compartilhar o nosso conhecimento com a comunidade. Na Flex Brasil , na FlexDev e em nossos blogs é provável que você já tenha encontrado algo que procura. E nunca pedimos nada em troca.

O que nos move não é nada material, mas sim a paixão pelo que fazemos e a convicção de que ao nos doar um pouco para a comunidade estamos ajudando e evoluindo conseqüentemente. Por estes mesmos motivos, estaremos todos reunidos dia 06 de fevereiro de 2010.

Temos muitas coisas que amamos para compartilhar com vocês. Porém, desta vez, queremos algo em troca. Algo que com certeza não lhe fará falta, mas que fará a diferença na vida das crianças do Cotolengo . Ganham vocês. Ganhamos nós. E, principalmente, ganham as crianças do Cololengo .

Assinam o Manifesto:
Beck Novaes, Carlos Eduardo, Daniel Lopes, Ebertom Consolim, Eric Cavalcanti, Fabio Vedovelli, Gabriela Perry, Igor Costa, Igor Musardo, Mario Junior e Vicente Maciel Junior.

Registre-se agora no Flex for Kids e ajude as crianças do Cotolengo . Porque alguém, já ajudou você um dia (e de quebra assista palestras que estão sendo preparadas com a mesma paixão de sempre).

Serão 10 palestras on-line ao vivo durante o dia inteiro, usando um ambiente de eventos multimídia onde os palestrantes ministrarão seus temas através de recursos de áudio, vídeo, slides e chat disponibilizado pela E-Genial.

Qualquer pessoa, empresa ou faculdade poderá participar do Flex for Kids, para isto basta fazer uma doação de um valor simbólico de R$ 30,00 para ter acesso as 10 palestras on-line e suas gravações que serão disponibilizadas 15 dias após o evento. Por isso não há desculpas para você não participar.

Todo dinheiro arrecadado será doado ao Cotolengo de Mato Grosso do Sul.

Garanta logo sua vaga e ajude a divulgar o evento para sua rede de contatos, assim como a Info Online fez.

Acesse o site do evento para maiores informações e inscrição: http://flexforkids.com

Na Class Library criei um arquivo ADO.NET Entity Data Model, onde fiz o mapeamento das tabelas do banco de dados.

Configurei o Website para utilizar o modelo do Entity Framework da Class Library e ao executar o projeto estourou o erro abaixo:

The specified named connection is either not found in the configuration, not intended to be used with the EntityClient provider, or not valid.

Após pesquisar encontrei a solução:

Copie a string de conexão do app.config da Class Library para o Web.Config do Website que o .NET Framework passará a encontrar a conexão com o banco de dados.

Divirta-se.

Esse erro ocorria sempre ao acessar dois módulos que tivessem DataGrid com eventos de clique. Acessando o primeiro módulo, tudo funcionava perfeitamente, porém ao acessar o segundo módulo e clicar em qualquer parte da DataGrid, o erro surgia.

Após várias pesquisas acabei encontrando duas soluções.

1ª Solução:

Mude o modo de linkagem do framework para Runtime Shared Library (RSL), disponível em:

Project Properties | Flex Build Path | Library Path | Framework linkage

Conforme na imagem abaixo:

2ª solução:

Mude o Application Domain do ModuleLoader para currentDomain.

var Mod:ModuleLoader = new ModuleLoader();
Mod.applicationDomain = ApplicationDomain.currentDomain;

Pronto, utilizando qualquer uma das soluções seu projeto agora funcionará perfeitamente.

Divirta-se.

Entre os destaques deste RC estão:

• Correções de Bug’s;
• Foco total em otimização e performance;
• Scripts de validação no cliente, que agora suporta globalização;
• Alterações na ValidationSummary.

Lista completa de alterações você encontra aqui.

A versão RTM está prevista para Março de 2010, até lá baixe o RC e continue seus estudos da Versão 2 do ASP.NET MVC.

Se você é desenvolvedor a algum tempo com certeza já se deparou com a questão da promoção de sênior a gerente. Por algumas razões que iremos analisar as pessoas não só aceitam este fato como esperam por ele.

Não é incomum durante uma entrevista perguntar para o candidato a uma vaga de desenvolvedor onde ele se vê daqui a 5 – 10 anos, e a resposta costuma ser “como gerente”. A razão para isso é simples: dinheiro. Historicamente a pessoa na posição de Gerente ganha mais que a pessoa na posição de desenvolvedor, seja qual for a sua classificação ou maturidade. Mas esse, espante-se, não é o único fator. A chamada da sereia do poder é prazerosa.

As empresas acham que promover a pessoa de desenvolvedor sênior para gerente é uma coisa boa. Não é. E as pessoas na sua extrema visão curta só enxergam essa opção.  Não é segredo que todos queremos ganhar mais, então quando a pessoa diz que quer ser gerente o que ele está dizendo, na verdade, é que quer mais dinheiro. Nesse ponto eu desclassifico o candidato já que ele ainda não deixou de ser júnior e já quer ficar mandando nos outros.

Por razões que o tempo conhece as empresas se habituaram a pensar que criar software é difícil e que a probabilidade do projeto de software dar errado é grande. Portanto, os diretores que não querem ver o seu na reta adotam a política de: 1) por um lado criar bodes expiatórios na pessoa do gerente. Se o projeto der errado eles serão culpabilizados e o diretor manterá o seu emprego; 2) é preciso microcontrolar tudo o que os desenvolvedores fazem para que assim não existam imprevistos e não existam atrasos.

O curioso é que são exatamente essas medidas de “contingência” que fazem o projeto atrasar.

O resultado é que em uma hierarquia de um diretor de produção de software é comum existirem vários “gerentes”, os quais tentam microcontrolar a equipe de desenvolvimento. A pessoa no papel de gerente  rapidamente  sacrifica os membros  da equipe para manter um salário um pouco melhor que eles sendo que ele seria incapaz de realizar o mesmo trabalho. A imagem do feitor de escravos me vem à mente.  O pior de tudo nem sequer é isso. O pior de tudo é que, normalmente, a pessoa na posição de gerente não tem capacidade técnica nem política para desempenhar esse papel. Sim, a pessoa foi desenvolvedor sênior 20 anos atrás. Isso não lhe dá conhecimento nenhum sobre como o software é feito hoje.  Não apenas a linguagem e o paradigma utilizado hoje são diferentes, como também as técnicas e ferramentas em volta (uso de repositório de código, por exemplo). Quanto mais cedo a pessoa passou de sênior a gerente mais óbvio é este fato, no limite absurdo de comparar, por exemplo, a plataforma Java com linguagens como Clipper, Delphi ou VisualBasic. Você já reparou como o seu gerente reduz tudo a operações no banco de dados e desconhece o conceito de “Servidor de Aplicação” ou o confunde com “servidor web” ?

Quanto à parte política, a pessoa na posição de gerente não tem qualquer escrúpulo ou vergonha em pedir ao desenvolvedor para trabalhar extra para manter o (famoso) cronograma. Mas  peraí! Não é o gerente que criou o cronograma? Se houver atraso não é responsabilidade dele? Infelizmente no mundo atual não. Nada nunca é responsabilidade do gerente e ele faz de tudo para que assim não seja. O clássico é pedir que os desenvolvedores estimem o cronograma. Ele pede que “estimem” mas o que ele quer dizer é “assinem com sangue um chute de quanto tempo vai ser necessário”. Depois o gerente faz a seguinte conta: se a “estimativa” é X então como temos N desenvolvedores vai demorar X/N tempo. A estimativa … quer dizer, a corda no pescoço da equipe de escra… desenvolvedores ficou ainda mais apertada. Nestas condições totalmente indecentes a equipa tem zero motivação , zero ajuda, zero autoridade, total responsabilidade e lá para quando faltarem dois meses para o final do prazo do cronograma fajuto a equipa ainda passa a ser chicoteada diariamente com a pergunta “Quantos porcento falta para estar pronto?”. O que revela que a pessoa no lugar de gerente não sabe o estado das coisas, ou seja, ela esteve fazendo o quê enquanto os desenvolvedores criavam o software? Esperar-se-ia que estivesse exatamente calculando quanto tempo falta. Certo ?

O diretor (a pessoa hierarquicamente acima do gerente e que o contratou como bode expiatório profissional) não se preocupa com a performance do gerente. Apenas com a da equipe. Afinal todos os males advém da equipe de desenvolvedores. Esses seres abjetos que o diretor é obrigado a tolerar para poder vender alguma coisa a alguém. Ao diretor tanto lhe faz se o gerente explora os desenvolvedores da mesma forma que o senhor lhe importa um pepino que o feitor chicoteie os seus escravos. Não só isso, como o diretor espera que o gerente aja assim.  Tanto isso é verdade que em empresas maiores (leia-se “com mais níveis de isolamento dos seres abjetos da equipe”) existem uma camada de gerentes. O diretor delega para N gerentes, cada um deles delega para M outros gerentes, que delegam a outros … em um cadeia até que se chega no gerente que controla a equipe. Vejam bem o estado da coisa. O gerente não serve para gerenciar o projeto. Não. Isso é fácil, qualquer excel ou project pode fazer isso. O gerente serve para controlar a equipe em uma mistura de babysiter com capataz e a empresa é tanto maior quanto mais gerentes forem controlados por outros gerentes.

Parece então óbvio porque um desenvolvedor quer virar gerente: 1) mais dinheiro no fim do mês; 2) menor ou nenhuma responsabilidade sobre o projeto ou o software; 3) direitos de fustigar a equipe como e quanto quiser; 4) receber todos os louros dos superiores quando o projeto dá certo; e 5) nunca ser “castigado” por nada.

Parece muito melhor que a vida de um desenvolvedor que 1) ganha pouco para aquilo que faz e a responsabilidade que tem; 2) tem toda a responsabilidade sobre o resultado mas nenhum autoridade para guiar o processo; 3) é interrompido a todo o momento com perguntas idiotas que não são da sua responsabilidade responder como “Quantos porcento do projeto já está completo?” 4) nunca recebe o agradecimento real de ninguém nem o reconhecimento real do esforço (eu disse real e não aquele tapinha nas costas ou aquele e-mail de agradecimento modelo B) e 5) é sempre “castigado” por tudo no limite de ser despedido por justa causa por erros cometidos pelo gerente, pelo diretor ou até pelo erro estratégico da empresa como um todo.

Se você teve estômago para ler até aqui, parabéns. Vejamos agora um pouco do outro lado. Afinal, nem todo o mundo é mentecapto e alguma pessoas querem realmente ganhar dinheiro a sério e não apenas para pagar as contas. Qualquer economista, por muito ruim que seja, sabe que uma forma de ganhar mais é gastar menos. É fácil gastar menos com desenvolvimento de software.

Primeiro, foque no que dá dinheiro. No caso do software o que dá dinheiro é o software, funcional e entregue. Muito importante o entregue.

Segundo, desenvolvedores são pessoas com educação superior e qualificadas a resolver problemas lógicos e matemáticos complexos. Não os trate como animais de curral. Converse com eles e ouça o que eles dizem. Melhor que ninguém eles sabem quais são os problemas com o software. E ninguém melhor que ele sabe como traduzir o que é esperado pelo mercado em código. Eles podem ajudá-lo não apenas a resolver problemas técnicos mas até problemas que impactaram na venda do software ou na aceitação pelo público. O seu foco é fazer software, então dê recursos aos desenvolvedores para o fazerem. O foco da empresa é o software e todos devem ajudar a conseguir que ele seja feito nas melhores condições de mercado possíveis.  Simplifique os processos. Coloque no lixo a hierarquia militar de passar ordens entre níveis.  Muita informação se perde dessa forma quando o assunto é complexo como um software. Pode até funcionar para a guerra onde as ordens são simples, mas não numa empresa de software.  Uma muito boa forma de conseguir isto com facilidade, sem gastar dinheiro e com um retorno imediato é substituir todos os que se dizem gerentes por desenvolvedores sênior (realmente sênior e não apenas júniors disfarçados). Implementar Scrum também não é má ideia, mas se você tem um outro processo que realmente funciona para a sua empresa (eu disse, realmente - o que significa que todo o mundo na empresa acha que funciona) então mantenha esse.

Implemente um mecanismo de carreira. Não separe os desenvolvedores por anos de trabalho  e sim preveja que todos têm mais do que uma habilidade. Não é demérito para ninguém só saber programar bem. Saber escrever código limpo, bem estruturado, que aproveita ao máximo as funcionalidades da linguagem não é pecado. Nem todos têm  de ser arquitetos. Não é demérito para ninguém ser um bom tester que sabe escrever testes automáticos com boa cobertura.

A vida de um desenvolvedor têm várias partes e não são: júnior , sênior, gerente. São: programador, engenheiro,  tester, designer, analista e arquiteto. E isto não é uma sequência. Cada um pode ser mais do que uma coisa. Aliás tem que ser mais do que uma. Existe o básico que é ser programador (saber programar não é suficiente) e existe o complexo: analise é uma tarefa ao mesmo tempo técnica, interpessoal e até política onde poucos engenheiros e arquitetos se sentem bem. Moral da história, monte uma equipe multidisciplinar sem gerentes fustigadores mas com pessoas que ajudem a resolver os problemas políticos, burocráticos e administrativos e deixe o desenvolvimento com quem entende.

A próxima década não terá pena de quem não se ajustar à nova ordem. Quem ainda quiser ficar fuçando no código como se fazia à 20 ou 30 anos atrás não vai chegar a lado nenhum diferente da falência. A concorrência é maior que nunca e o mercado de tecnologia é maior do que nunca. Quem não primar pela qualidade não vai vingar.

A escravatura das fábricas de software tem que acabar. O primeiro passo é que você, desenvolvedor,  não aceite esses termos.  Aspire a ter capacidades de análise, conhecimento de arquitetura, design ou teste, e não a ser um gerente mentecapto e escravocrata.  Afinal, você gostaria que pensassem de si o que você pensa do seu gerente?

Vivemos uma época transformadora no desenvolvimento de software. A partir da segunda década do século XXI só vai sobreviver quem fizer software barato (leia-se: sem “gordura”),  recheado de valor, feito com responsabilidade e entregue no prazo. É a hora de separar o trigo do joio.

Os sufixos júnior e sênior me aborrecem enormemente desde sempre. Especialmente quando utilizados fora de contexto ou como sinônimos de “tempo de serviço”. Mas o que realmente faz de você um júnior ou um sênior?

A resposta a esta pergunta pode não ser o que você esperava ouvir. Mas se quiser trabalhar com software nos próximos decênios é bom que a aceite.

A diferença entre júnior e sênior não está na idade, nem no tempo de serviço. Está na maturidade técnica e na maturidade profissional.

Para um júnior, trabalhar muito é sinônimo de “bom”. Trabalhar até altas horas e acumular um monte de horas extra é um sinal de dignidade. Para um sênior só de isso ser sugerido, é um insulto. O sênior sabe que se algo der errado não é com horas a mais ou fins de semana longe da família que o problema se resolve. Bem pelo contrário. Se agrava. Então a posição do sênior é não ter problemas. Para isso ele usa todos os seus skills técnicos para que problemas não aconteçam ou sejam facilmente mitigados. Um bom design, uma bateria de testes automatizados e muito refactoring são ferramentas básicas do sênior para não deixar “a vaca ir pro brejo”.

Para um júnior, boas práticas são subjetivas e discutíveis e gambiarra é um martelinho de ouro que resolve todos os problemas com uma pancada só. Para o sênior, as boas práticas são como leis da natureza, objetivas e irrevogáveis, e a gambiarra um pecado demoníaco intolerável que tem ser exorcizado a qualquer custo de todo aquele de quem se apodera. O sênior sabe que seguir bons princípios e boas práticas fazem as coisas fluírem mais facilmente e responder mais eficazmente a imprevistos enquanto o júnior ignora que as suas gambiarras são aquilo que está fazendo seus fins de semana serem perdidos na empresa ao invés de poder estar em casa ou em passeio com os amigos ou a namorada.

O júnior acha que o objetivo de construir um software é fazer o programa funcionar. O sênior sabe que o objetivo de criar um software é fazer uma aplicação de fácil manutenção. Pois é na manutenção que está o custo e não na criação.

O júnior acha que com 3 anos de serviço pode ser um pleno. Um pleno tapado será se pensa que o tempo traz experiência. O trabalho é que traz experiência. O sênior sabe que desenvolver software é uma arte e um arte não se aprende com o tempo e sim com a prática.

O júnior tende a usar pouco a cabeça, tentando seguir ao máximo “receitas de bolo”, sem se ater ao contexto. O sênior racionaliza o problema e encontra a solução mais flexível até à solução. Normalmente esta solução só é possível com o uso de alguma técnica avançada de desenvolvimento de software como o uso de  objetos  em vez de rotinas. Como para o júnior boas práticas são piadas que se contam aos amigos este tipo de técnica passa

É tempo de inovar com seu currículo!!!

O Centro de Inovação Microsoft de Curitiba , através de sua iniciativa de desenvolvimento da economia local de software, tem o prazer de convidá-lo para o Innovation Day, um evento técnico sobre as mais novas tecnologias Microsoft e informações sobre o mercado de TI.

Data: 04/07 (Sábado)
Horário: 10h00min às 17h30min
Local: Centro Tecnológico da Universidade Positivo
Rua Alf. Ângelo Sampaio,2300 – Auditório

Programação

O Evento será gratuito para todo o público. Não perca essa oportunidade!

Confirme sua presença até o dia 03/07 pelo telefone (41) 3335-7612, com Cláudia, ou pelo e-mail mic@techresult.com.br.

No dia 14 de maio aconteceu em Curitiba o 11º Encontro de Profissionais da Internet promovido pela Locaweb.

Fomos ao evento eu, Igor Musardo, e o Tagôre Cauê, e lá encontramos o SaintBR.

Eu e o SaintBR no CofeeBreak.

O evento foi bem interessante com palestras bacanas, embora ache que para os próximos anos possam ter sessões de desenvolvimento e de design ocorrendo em paralelos e com conteúdo mais técnico e profundo como será no 14º Encontro de Design e Tecnologia Digital que ocorrerá dia 6 de junho também em Curitiba.

A palestra mais aguardada foi a do Fabio Akita com o tema desenvolvimento ágil. O Fabio abordou de forma simples e clara a essência do desenvolvimento ágil de software, infelizmente o tempo foi curto para a palestra do Akita e por isso perdemos alguns conceitos e conclusões de raciocínios.

Consegui gravar boa parte da palestra, portanto se você não pode comparecer ao evento assista agora. A palestra está separada em quatro partes.

Os slides, o próprio Akita já disponibilizou.

O gráfico de cascata (waterfall, também conhecido como, flying bricks chart em inglês) é uma ferramenta que facilita a demonstração de parcelas de um valor. Ele é muito utilizado na apresentação da divisão da receita e exibição do que resta de lucro em DRE, da entrada de caixa ao saldo final em demonstrativos de Fluxo de Caixa, mas pode-se utilizá-lo em qualquer situação em que seja necessário mostrar a “quebra” de um número.

Neste artigo vou demonstrar como desenvolver um gráfico de cascata em Adobe Flex estendendo um ColumnChart de forma simples obtendo como resultado o exemplo abaixo.

Primeiro precisamos entender qual a estrutura do gráfico de cascata. Ele é um gráfico de colunas do tipo empilhado (stacked) com 6 séries conforme demonstrado na figura abaixo:

• 1 – Base, que será invisível;
• 2 – Vermelho Positivo, série da cor vermelha que será exibida acima do zero, ex. (-) Custos no gráfico acima;
• 3 – Verde Positivo, série da cor verde que será exibida acima do zero, ex. Resultado não Op.;
• 4 – Vermelho Negativo, série da cor vermelha que será exibida abaixo do zero, ex. (-) Despesas;
• 5 – Verde Negativo, série da cor verde que será exibida abaixo do zero, ex. Resultado não Op.;
• 6 – Saldo, série da cor azul, ex. Lajir.

No componente que criaremos apenas será necessário passar um DataProvider com as colunas: eixo, valor e isSaldo. Com base nos dados deste DataProvider o Gráfico Cascata criará todas as 6 séries necessárias, já com os valores calculados.

Veja como o componente é implementado abaixo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697

package br.com.igormusardo.component.chart
{
	import mx.charts.*;
	import mx.charts.chartClasses.IAxis;
	import mx.charts.series.ColumnSeries;
	import mx.charts.series.ColumnSet;
	import mx.charts.series.items.*;
	import mx.collections.ArrayCollection;
	import mx.effects.easing.*;
	import mx.formatters.NumberFormatter;
	import mx.graphics.GradientEntry;
	import mx.graphics.LinearGradient;
	import mx.graphics.SolidColor;
	import mx.graphics.Stroke;
	import mx.utils.ObjectUtil;
 
	public class WaterfallChart extends ColumnChart
	{
		[Bindable]
		private var _calculateRange:Boolean;
 
		[Bindable]
		private var _backgroundColor:uint;
 
		[Bindable]
		private var _best:Number;
 
		[Bindable]
		private var _precision:Number;
 
		[Bindable]
		private var _decimalSeparator:String;
 
		[Bindable]
		private var _thousandsSeparator:String;
 
		private var dataProviderOriginal:ArrayCollection = new ArrayCollection();
		private var format:NumberFormatter = new NumberFormatter;		
		private var	columnBase:ColumnSeries = new ColumnSeries();
		private var	columnSaldo:ColumnSeries = new ColumnSeries();
		private var	columnVermelhoPositivo:ColumnSeries = new ColumnSeries();
		private var	columnVerdePositivo:ColumnSeries = new ColumnSeries();
		private var	columnVermelhoNegativo:ColumnSeries = new ColumnSeries();
		private var	columnVerdeNegativo:ColumnSeries = new ColumnSeries();
 
		public function WaterfallChart()
		{
			super();	
			calculateRange = true;
			backgroundColor = 0xFFFFFF;
			best = 1;
			precision = 0;
			decimalSeparator = ',';
			thousandsSeparator = '.';			
			createChart();
		}
 
		override protected function initializationComplete():void
		{
			changeStyles();
			super.initializationComplete()
		}
 
 
		//Propriedades 
		////////////////////////////////////////////////////////////////////////////////////////
		//calculateRange, quando Verdadeiro o componente calcula a diferença entre as séries, exibindo somente os valores que somaram ou reduziram de uma série para a outra.
		public function set calculateRange(value:Boolean):void
		{
			_calculateRange = value;
			changeDataProvider();	
		}
 
		public function get calculateRange():Boolean
		{
			return _calculateRange;	
		}
 
		public function set backgroundColor(value:uint):void
		{
			_backgroundColor = value;	
			changeStyles();	
		}
 
		public function get backgroundColor():uint
		{
			return _backgroundColor;	
		}
 
		//best, define qual é o melhor (1 melhor para cima, verde quando aumenta e vermelho quando diminui, 2 melhor para baixo, verde quando diminiui e vermelho quando aumente)
		public function set best(value:Number):void
		{
			_best = value;	
			changeDataProvider();	
		}
 
		public function get best():Number
		{
			return _best;	
		}
 
		//precision, define o número de casas decimais.
		public function set precision(value:Number):void
		{
			_precision = value;
			format.precision=_precision;
		    invalidateProperties();
		    invalidateDisplayList();   		
		}
 
		public function get precision():Number
		{
			return _precision;	
		}	
 
		//decimalSeparator, define qual o separador de decimal, padrão ,
		public function set decimalSeparator(value:String):void
		{
			_decimalSeparator = value;	
    		format.decimalSeparatorTo=_decimalSeparator;
		    invalidateProperties();
		    invalidateDisplayList();   		
		}
 
		public function get decimalSeparator():String
		{
			return _decimalSeparator;	
		}	
 
		//thousandsSeparator, define qual o separador de milhar, padrão .
		public function set thousandsSeparator(value:String):void
		{
			_thousandsSeparator = value;	
    		format.thousandsSeparatorTo=_thousandsSeparator;
		    invalidateProperties();
		    invalidateDisplayList();   		
		}
 
		public function get thousandsSeparator():String
		{
			return _thousandsSeparator;	
		}	
 
		private function createChart():void		
		{
			seriesFilters=[];
			dataTipMode="single";
			dataTipFunction=chartTipFunction;			
			maxLabelWidth=100;
 
			var columnSet:ColumnSet = new ColumnSet();
			var hAxis:CategoryAxis = new CategoryAxis()
			var vAxis:LinearAxis = new LinearAxis()
			var columnSerie:ColumnSeries = new ColumnSeries();
			var stroke:Stroke;
			var linearGradient:LinearGradient;
			var solidColor:SolidColor;
			var gradientEntry:GradientEntry;
			var gradArray:Array;
 
			vAxis.labelFunction = alteraLabelVertical;	
			verticalAxis = vAxis;
 
			hAxis.dataProvider = this.dataProvider;
			hAxis.categoryField = "eixo";
			hAxis.labelFunction = alteraLabelHorizontal;		
			horizontalAxis = hAxis;
 
			//Define o columnSet do gráfico
			columnSet.type = "stacked";
			columnSet.allowNegativeForStacked = true;
 
			/////////////////////////////////////////////////////////////////////////////////
			//Início da configuração da série vlrSaldo
			//Define a configuração da linha
			stroke = new Stroke();
			stroke.alpha = 0;
			stroke.weight = 0;
 
			//Início configuração Degradê de cores para a série vlrSaldo			
			linearGradient = new LinearGradient();
			linearGradient.angle = 0;
 
			gradientEntry = new GradientEntry()
			gradientEntry.color = 0x003ea5;
			gradientEntry.ratio = 0;
			gradientEntry.alpha = 1;
 
			gradArray = new Array();		
			gradArray.push(gradientEntry);
 
			gradientEntry = new GradientEntry()
			gradientEntry.color = 0x0060ff;
			gradientEntry.ratio = .5;
			gradientEntry.alpha = 1;
			gradArray.push(gradientEntry);
 
			gradientEntry = new GradientEntry()
			gradientEntry.color = 0x003ea5;
			gradientEntry.ratio = 1;
			gradientEntry.alpha = 1;						
			gradArray.push(gradientEntry);
 
			linearGradient.entries = gradArray;
			//Fim configuração Degradê de cores para a série vlrSaldo
 
			columnSaldo.yField = "vlrSaldo";
			columnSaldo.labelField = "vlrSaldo";
			columnSaldo.setStyle("stroke",stroke);
			columnSaldo.setStyle("fill",linearGradient);
			//Fim configuração da série vlrSaldo
 
			//Inclui a série vlrSaldo às séries do ColumnSet
			columnSet.series.push(columnSaldo);
			/////////////////////////////////////////////////////////////////////////////////
 
			/////////////////////////////////////////////////////////////////////////////////
			//Início da configuração da série vlrBase
 
			columnBase.yField = "vlrBase";
			columnBase.setStyle("stroke",stroke);
			//Fim configuração da série vlrSaldo
 
			//Inclui a série vlrBase às séries do ColumnSet
			columnSet.series.push(columnBase);
			/////////////////////////////////////////////////////////////////////////////////
 
			/////////////////////////////////////////////////////////////////////////////////
			//Início da configuração da série vlrVermelhoPositivo
			//Define a configuração da linha
			stroke = new Stroke();
			stroke.alpha = 0;
			stroke.weight = 0;
 
			//Início configuração Degradê de cores para a série vlrVermelhoPositivo			
			linearGradient = new LinearGradient();
			linearGradient.angle = 0;
 
			gradientEntry = new GradientEntry()
			gradientEntry.color = 0xa50000;
			gradientEntry.ratio = 0;
			gradientEntry.alpha = 1;
 
			gradArray = new Array();		
			gradArray.push(gradientEntry);
 
			gradientEntry = new GradientEntry()
			gradientEntry.color = 0xff0000;
			gradientEntry.ratio = .5;
			gradientEntry.alpha = 1;
			gradArray.push(gradientEntry);
 
			gradientEntry = new GradientEntry()
			gradientEntry.color = 0xa50000;
			gradientEntry.ratio = 1;
			gradientEntry.alpha = 1;						
			gradArray.push(gradientEntry);
 
			linearGradient.entries = gradArray;
			//Fim configuração Degradê de cores para a série vlrVermelhoPositivo
 
			columnVermelhoPositivo.yField = "vlrVermelhoPositivo";
			columnVermelhoPositivo.labelField = "vlrVermelhoPositivo";
			columnVermelhoPositivo.setStyle("stroke",stroke);
			columnVermelhoPositivo.setStyle("fill",linearGradient);
			//Fim configuração da série vlrSaldo
 
			//Inclui a série vlrVermelhoPositivo às séries do ColumnSet
			columnSet.series.push(columnVermelhoPositivo);
			/////////////////////////////////////////////////////////////////////////////////
 
			/////////////////////////////////////////////////////////////////////////////////
			//Início da configuração da série vlrVerdePositivo
			//Define a configuração da linha
			stroke = new Stroke();
			stroke.alpha = 0;
			stroke.weight = 0;
 
			//Início configuração Degradê de cores para a série vlrVerdePositivo			
			linearGradient = new LinearGradient();
			linearGradient.angle = 0;
 
			gradientEntry = new GradientEntry()
			gradientEntry.color = 0x00a500;
			gradientEntry.ratio = 0;
			gradientEntry.alpha = 1;
 
			gradArray = new Array();		
			gradArray.push(gradientEntry);
 
			gradientEntry = new GradientEntry()
			gradientEntry.color = 0x60ff00;
			gradientEntry.ratio = .5;
			gradientEntry.alpha = 1;
			gradArray.push(gradientEntry);
 
			gradientEntry = new GradientEntry()
			gradientEntry.color = 0x00a500;
			gradientEntry.ratio = 1;
			gradientEntry.alpha = 1;						
			gradArray.push(gradientEntry);
 
			linearGradient.entries = gradArray;
			//Fim configuração Degradê de cores para a série vlrVerdePositivo
 
			columnVerdePositivo.yField = "vlrVerdePositivo";
			columnVerdePositivo.labelField = "vlrVerdePositivo";
			columnVerdePositivo.setStyle("stroke",stroke);
			columnVerdePositivo.setStyle("fill",linearGradient);
			//Fim configuração da série vlrVerdePositivo
 
			//Inclui a série vlrVerdePositivo às séries do ColumnSet
			columnSet.series.push(columnVerdePositivo);
			/////////////////////////////////////////////////////////////////////////////////
 
			/////////////////////////////////////////////////////////////////////////////////
			//Início da configuração da série vlrVermelhoNegativo
			//Define a configuração da linha
			stroke = new Stroke();
			stroke.alpha = 0;
			stroke.weight = 0;
 
			//Início configuração Degradê de cores para a série vlrVermelhoNegativo			
			linearGradient = new LinearGradient();
			linearGradient.angle = 0;
 
			gradientEntry = new GradientEntry()
			gradientEntry.color = 0xa50000;
			gradientEntry.ratio = 0;
			gradientEntry.alpha = 1;
 
			gradArray = new Array();		
			gradArray.push(gradientEntry);
 
			gradientEntry = new GradientEntry()
			gradientEntry.color = 0xff0000;
			gradientEntry.ratio = .5;
			gradientEntry.alpha = 1;
			gradArray.push(gradientEntry);
 
			gradientEntry = new GradientEntry()
			gradientEntry.color = 0xa50000;
			gradientEntry.ratio = 1;
			gradientEntry.alpha = 1;						
			gradArray.push(gradientEntry);
 
			linearGradient.entries = gradArray;
			//Fim configuração Degradê de cores para a série vlrVermelhoNegativo
 
			columnVermelhoNegativo.yField = "vlrVermelhoNegativo";
			columnVermelhoNegativo.labelField = "vlrVermelhoNegativo";
			columnVermelhoNegativo.setStyle("stroke",stroke);
			columnVermelhoNegativo.setStyle("fill",linearGradient);
			//Fim configuração da série vlrVermelhoNegativo
 
			//Inclui a série vlrVermelhoNegativo às séries do ColumnSet
			columnSet.series.push(columnVermelhoNegativo);
			/////////////////////////////////////////////////////////////////////////////////
 
			/////////////////////////////////////////////////////////////////////////////////
			//Início da configuração da série vlrVerdeNegativo
			//Define a configuração da linha
			stroke = new Stroke();
			stroke.alpha = 0;
			stroke.weight = 0;
 
			//Início configuração Degradê de cores para a série vlrVerdeNegativo			
			linearGradient = new LinearGradient();
			linearGradient.angle = 0;
 
			gradientEntry = new GradientEntry()
			gradientEntry.color = 0x00a500;
			gradientEntry.ratio = 0;
			gradientEntry.alpha = 1;
 
			gradArray = new Array();		
			gradArray.push(gradientEntry);
 
			gradientEntry = new GradientEntry()
			gradientEntry.color = 0x60ff00;
			gradientEntry.ratio = .5;
			gradientEntry.alpha = 1;
			gradArray.push(gradientEntry);
 
			gradientEntry = new GradientEntry()
			gradientEntry.color = 0x00a500;
			gradientEntry.ratio = 1;
			gradientEntry.alpha = 1;						
			gradArray.push(gradientEntry);
 
			linearGradient.entries = gradArray;
			//Fim configuração Degradê de cores para a série vlrVerdeNegativo
 
			columnVerdeNegativo.yField = "vlrVerdeNegativo";
			columnVerdeNegativo.labelField = "vlrVerdeNegativo";
			columnVerdeNegativo.setStyle("stroke",stroke);
			columnVerdeNegativo.setStyle("fill",linearGradient);
			//Fim configuração da série vlrVerdeNegativo
 
			//Inclui a série vlrVerdeNegativo às séries do ColumnSet
			columnSet.series.push(columnVerdeNegativo);
 
			/////////////////////////////////////////////////////////////////////////////////
			setStyle("columnWidthRatio",0.9);
 
			series = [columnSet];
		}
 
		//Métodos formatação do gráfico
		////////////////////////////////////////////////////////////////////////////////////////
		//chartTipFunction, exibe o popup com os valores ao posicionar o mouse sobre a série.
		private function chartTipFunction(hitData:HitData):String
		{		
			return format.format(hitData.item.vlrValor);
		}
 
		private function alteraLabelHorizontal(item:Object, prevValue:Object, axis:CategoryAxis, categoryItem:Object):String
		{
			var retorno:String="";
			var tamanho:int=String(item).length;
 
			retorno=String(item)
 
			return retorno;
		}
 
		private function alteraLabelVertical(item:Object, prevValue:Object, axis:IAxis):String
		{				
			return format.format(item);
		}
 
		private function changeStyles():void
		{
			//Início configuração da cor de fundo do gráfico
			var bgi:GridLines = new GridLines();
			bgi.setStyle("horizontalStroke", new Stroke(_backgroundColor, 1));
			bgi.setStyle("horizontalFill", new SolidColor(_backgroundColor, 100));
			bgi.setStyle("horizontalAlternateFill", new SolidColor(_backgroundColor, 100));
			backgroundElements = [bgi]
			//Fim configuração da cor de fundo do gráfico	
 
			//Início configuração da cor da série Base
			var solidColor:SolidColor = new SolidColor();
			solidColor.alpha = 1;
			solidColor.color = _backgroundColor;
			columnBase.setStyle("fill",solidColor);
			//Fim configuração da cor da série Base
 
		    invalidateProperties();
		    invalidateDisplayList();
		}
 
 
		//Série base (invisível) do gráfico
		private function calculaSerieBase(vlrSaldoAnterior:Number,vlrValorCorrente:Number):Number
		{
			var retorno:Number;
			var vlrSaldoAtual:Number=vlrSaldoAnterior+vlrValorCorrente;
 
			if ((vlrSaldoAnterior>0 && vlrSaldoAtual<0)||(vlrSaldoAnterior<0 && vlrSaldoAtual>0))
			{
				retorno=0;
			}
			else
			{
				if (vlrSaldoAnterior>0 && vlrSaldoAtual>0)
				{
					retorno=vlrSaldoAnterior-calculaSerieDebitoPositivo(vlrSaldoAnterior,vlrValorCorrente);
				}
				else
				{
					if (vlrSaldoAnterior<0 && vlrSaldoAtual<0)
					{
						retorno=vlrSaldoAnterior+calculaSerieCreditoNegativo(vlrSaldoAnterior,vlrValorCorrente);
					}
					else
					{
						retorno=0;
					}		
				}
			}
 
			return retorno;
		}
 
		//Série verde valor positivo
		private function calculaSerieCreditoPositivo(vlrSaldoAnterior:Number, vlrValorCorrente:Number):Number
		{
			var retorno:Number;
 
			if (vlrValorCorrente<=0)
			{
				retorno=0;
			}
			else 
			{
				if (vlrSaldoAnterior<0)
				{
					if (vlrValorCorrente>-vlrSaldoAnterior)
					{
						retorno=vlrValorCorrente+vlrSaldoAnterior;
					}
					else
					{
						retorno=0;
					}
				}
				else
				{
					retorno=vlrValorCorrente;
				}
			}
			return retorno;
		}	
 
 
		//Série verde valor negativo
		private function calculaSerieCreditoNegativo(vlrSaldoAnterior:Number, vlrValorCorrente:Number):Number
		{
			var retorno:Number;
 
			if (vlrValorCorrente<=0)
			{
				retorno=0;
			}
			else 
			{
				if (vlrSaldoAnterior>=0)
				{
					retorno=0;
				}
				else
				{
					if (vlrValorCorrente>-vlrSaldoAnterior)
					{
						retorno=vlrSaldoAnterior;
					}
					else
					{
						retorno=-vlrValorCorrente;
					}
				}
			}
			return retorno;
		}	
 
		//Série vermelho valor positivo
		private function calculaSerieDebitoPositivo(vlrSaldoAnterior:Number, vlrValorCorrente:Number):Number
		{
			var retorno:Number;
 
			if (vlrValorCorrente>=0)
			{
				retorno=0;
			}
			else 
			{
				if (vlrSaldoAnterior<=0)
				{
					retorno=0;
				}
				else
				{
					if(vlrSaldoAnterior<=Math.abs(vlrValorCorrente))
					{
						retorno=vlrSaldoAnterior;
					}
					else
					{
						retorno=-vlrValorCorrente;
					}
				}
			}
			return retorno;
		}
 
 
		//Série vermelho valor negativo
		private function calculaSerieDebitoNegativo(vlrSaldoAnterior:Number, vlrValorCorrente:Number):Number
		{
			var retorno:Number;
 
			if (vlrValorCorrente>=0)
			{
				retorno=0;
			}
			else 
			{
				if (vlrSaldoAnterior>0)
				{
					if(Math.abs(vlrValorCorrente)<=vlrSaldoAnterior)
					{
						retorno=0;
					}
					else
					{
						retorno=vlrSaldoAnterior+vlrValorCorrente;
					}
				}
				else
				{
					retorno=vlrValorCorrente;
				}
			}
 
			return retorno;
		}				
 
		//Métodos Geração das séries
		////////////////////////////////////////////////////////////////////////////////////////
		override public function set dataProvider(value:Object):void
    	{
			if(value is ArrayCollection)
				dataProviderOriginal = value as ArrayCollection;
			else
				dataProviderOriginal = new ArrayCollection(value as Array);
			changeDataProvider();
     	}
 
     	private function changeDataProvider():void
     	{    		
     		if(dataProviderOriginal.length == 0)
     			return;
 
     		var value:Object = ObjectUtil.copy(dataProviderOriginal);
    		var dataProviderOriginalDP:Array = new Array;
    		var vlrValorCorrente:Number;
    		var vlrSaldoAnterior:Number;
 
    		//Verifica se o array é válido
    		if(value[0].eixo==null || value[0].valor==null || value[0].isSaldo==null)
    		{
    			throw new Error('Array inválido, deve possuir os campos: eixo:String, valor:Number e isSaldo:Boolean');
    			return;
    		}
 
    		format.useNegativeSign='-';
    		format.useThousandsSeparator=true;
    		format.rounding="nearest";	
 
			if(calculateRange && value != null)
			{
				for(var index:int = value.length-1; index >= 0; index--)
				{
					if(value[index].isSaldo != true)			
						if(index > 0)
							value[index].valor = value[index].valor - value[index-1].valor;
					if(index==value.length-1 && value[index].isSaldo == true)
					{
						value.addItem(ObjectUtil.copy(value[index]));
						value[index].isSaldo = false;
					}					
				}
			}
 
    		//Percorre o array de dataProviderOriginal, montando as séries do gráfico
			for each (var Obj:Object in value)
			{
				if (Obj.isSaldo==true)
					vlrSaldoAnterior=0;
 
				vlrValorCorrente=Obj.valor;
 
				dataProviderOriginalDP.push({
							eixo:Obj.eixo,
							vlrSaldo:(Obj.isSaldo==true?vlrValorCorrente:0), //Se for saldo PLOTA esta série
							vlrBase:(Obj.isSaldo==true?0: //Se for saldo NÃO plota esta série
														calculaSerieBase(vlrSaldoAnterior,vlrValorCorrente)),
							vlrVermelhoPositivo:(Obj.isSaldo==true?0 //Se for saldo NÃO plota esta série
																	:(_best==2? //Se for melhor pra baixo inverte a cor do melhor pra cima
																				calculaSerieCreditoPositivo(vlrSaldoAnterior,vlrValorCorrente)
																				:calculaSerieDebitoPositivo(vlrSaldoAnterior,vlrValorCorrente))),
							vlrVerdePositivo:(Obj.isSaldo==true?0 //Se for saldo NÃO plota esta série
																	:(_best==2? //Se for melhor pra baixo inverte a cor do melhor pra cima
																				calculaSerieDebitoPositivo(vlrSaldoAnterior,vlrValorCorrente)
																				:calculaSerieCreditoPositivo(vlrSaldoAnterior,vlrValorCorrente))),
							vlrVermelhoNegativo:(Obj.isSaldo==true?0 //Se for saldo NÃO plota esta série
																	:(_best==2? //Se for melhor pra baixo inverte a cor do melhor pra cima
																				calculaSerieCreditoNegativo(vlrSaldoAnterior,vlrValorCorrente)
																				:calculaSerieDebitoNegativo(vlrSaldoAnterior,vlrValorCorrente))),
							vlrVerdeNegativo:(Obj.isSaldo==true?0 //Se for saldo NÃO plota esta série
																:(_best==2? //Se for melhor pra baixo inverte a cor do melhor pra cima
																			calculaSerieDebitoNegativo(vlrSaldoAnterior,vlrValorCorrente)
																			:calculaSerieCreditoNegativo(vlrSaldoAnterior,vlrValorCorrente))),
							vlrValor:vlrValorCorrente
						});
 
				vlrSaldoAnterior+=vlrValorCorrente;
			}
 
    		super.dataProvider = dataProviderOriginalDP;
		    invalidateProperties();
		    invalidateDisplayList();
     	}
 
	}
}

Para utilizar o novo componente, utilize o código:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" xmlns:ns1="br.com.igormusardo.component.chart.*" backgroundGradientAlphas="[1.0, 1.0]" backgroundGradientColors="[#FFFFFF, #FFFFFF]">
	<ns1:WaterfallChart id="wfc" top="10" left="10" right="10" bottom="10" showDataTips="true" calculateRange="false" best="1">
		<ns1:dataProvider>
			<mx:Array>
				<mx:Object eixo="ROB" valor="12850" isSaldo="true"/>
				<mx:Object eixo="(-) Deduções" valor="-1500" isSaldo="false"/>
				<mx:Object eixo="ROL" valor="11350" isSaldo="true"/>
				<mx:Object eixo="(-) Custos" valor="-8200" isSaldo="false"/>
				<mx:Object eixo="Lucro Bruto" valor="3150" isSaldo="true"/>
				<mx:Object eixo="(-) Desp. Op." valor="-3150" isSaldo="false"/>
				<mx:Object eixo="(-) Desp. Fi." valor="-1200" isSaldo="false"/>
				<mx:Object eixo="Res. Não Op. " valor="3500" isSaldo="false"/>
				<mx:Object eixo="Lajir" valor="2300" isSaldo="true"/>
			</mx:Array>
		</ns1:dataProvider>
	</ns1:WaterfallChart>
</mx:Application>

O resultado obtido é o demonstrado abaixo.

Se quiser fazer teste com o comportamento do gráfico teste-o logo abaixo…

Se preferir, faça o download do gráfico cascata já compilado em SWC. Download Gráfico Cascata.

Divirta-se…

Foi anunciado dia 10 de abril o lançamento do Rails Guides em Português. O trabalho começou a ser feito no ano passado de maneira colaborativa por vários integrantes da comunidade Rails do Brasil, você pode ver a lista completa aqui.

Para quem não conhece o projeto, ele é o sonho de consumo de qualquer desenvolvedor Rails – simples, abrangente, bonito e bem detalhado. Ele cobre a maior parte das necessidades diárias de um desenvolvedor de maneira bastante pragmática e ainda ensina o "Rails Way" quase sem querer. Você também pode ver a versão em inglês aqui.

Segundo Rafael Rosa, ainda faltam alguns artigos para serem traduzidos e revisados, mas uns 80% já estão disponíveis, e as atualizações virão de maneira incremental. Ele ainda informa que irão precisar de ajuda para traduzir e revisar novos itens, portanto, se você quiser participar acesse o wiki do projeto e siga as orientações. Esse projeto será "A" referência on-line sobre Rails em português, e isso só se tornou possível graças ao trabalho da comunidade. Divulgue, leia, colabore e deixe sua opinião.

Tudo isso em um único PDF.

Download

No mesmo embalo a Safari Books Online está oferecendo 60 dias de acesso a coleção de livros de Adobe Flex 3 e técnicas de desenvolvimento RIA, faça o seu cadastro em https://ssl.safaribooksonline.com/tryitfree.

Esta coleção inclui títulos oficiais da Adobe: Adobe Developer Library e Adobe Press.

Não perca esta oportunidade.

O Attest 1.5 emula a prova de certificação focando nos tópicos relevantes do exame. Os testes possuem 50 questões com 60 minutos para responder. Quando você conclui o teste, o Attest mostra os % de acerto em cada área, sendo possível salvar os resultados para consultar novamente depois ou até mesmo fazer o acompanhamento da evolução do estudo.

Quem deu essa dica originalmente foi Eberton Consolim em seu blog.

Bons estudos.