Netbeans!? Minhas impressões

Como muitos desenvolvedores, eu sou um eclipseiro de carteirinha. Uso o Eclipse profissionalmente desde mais ou menos a versão 2.0, passei pela 2.0.1, 2.0.2, 2.1 e por aí vai até a 3.3.2 de hoje, conhecida como Europa. Mas semana desde a semana passada eu estou utilizando o Netbeans, pois é, emprego novo, projeto em andamento e atrasado, corre corre, enfim, eu não consegui mudar para o Eclipse.

Por toda a minha carreira profissional, obviamente nem tudo foram flores, já utilizei outras IDEs e ferramentas, várias outras e por diversos motivos. Já passei por IntelliJ IDEA (essa é excepcional), JDeveloper (JDevil), JBuilder, BEA Weblogic Workshop (pífio, não estou falando da versão 10 que já é Eclipse, mas sim a 8 e anteriores) e até GEL e JCreator Pro, por mais estranho que pareça nunca havia usado o Netbeans num projeto de produção, pra valer mesmo e com uma equipe utilizando junto comigo.

Então eu nunca tinha usado o Netbeans? Claro que não! Eu adoro usar o Netbeans para fazer um showzinho no final das minha palestras e apresentações, sempre que sobra tempo. Principalmente nas apresentações sobre Introdução ao Java ME, aquele editor visual dele convence todos que ainda estavam em dúvida :D como dizem por aqui, é tiro e queda. Mas nunca foi muito além disso.

Então, hoje já completam duas semanas de uso do Netbeans 6.0.1, que é a última estável. Pois bem, vamos às minhas impressões neste tempo.

O que eu gostei:

  • As fontes da IDE são pequenas. Acho isso muito bom, poupa espaço na área visível para coisas mais importantes. O Eclipse (no windows vista e principalmente no gnome) deixa bastante a desejar nisso.
  • Não está demorando tanto para abrir. Mas ainda não é rápido :)

O que eu não gostei:

  • Não compila automagicamente (um viva ao JDT)
  • Os avisos de erro no projeto (aqueles ícones bonitinhos) ainda não funcionam direito.
  • O ‘Insert Code‘ não é nada sugestivo quando você pensa em gerar getters e setters ou sobrescrever algum método da classe pai.
  • CVS!? O suporte ao CVS é muito fraco. Com certeza é muito melhor que o do JDev e Weblogic Workshop, mas ainda assim é muito ruim, principalmente se você já usou o CVS no Eclipse antes. O merge seria mais legal se a IDE informasse que lado do código é o seu e qual é o remoto, mas isso você tem que adivinhar.
  • O gerenciamento de dependências não é dos melhores. Quando eu precisei adicionar um JAR ao projeto, a IDE me informava no Wizard o caminho completo do JAR no meu disco, apesar de eu ter deixado o JAR dentro do projeto, justamente para que o caminho não ficasse absoluto. Solução? Alterar o nbproject/project.properties na mão para que o caminho ficasse relativo ao projeto.
  • O consumo excessivo do heap ainda é um problema. Ao final de um dia inteiro de trabalho o heap da IDE já passou dos 500Mb fácil fácil.
  • Tinha mais alguma coisa que eu esqueci, assim que lembrar farei um novo relato.

Essas são as minhas impressões das duas primeiras semanas utilizando Netbeans. Um resumo para tudo? Que saudade do Eclipse.

Simplicidade, um velho novo conhecido

Muito tem se falado do retorno da simplicidade no desenvolvimento web com Java, simplicidade esta que, diga-se de passagem, nunca deveria ter sido posta de lado da forma que aconteceu. Creio que depois do auge do evento “re-inventando a roda” onde tudo era motivo para um novo framework, e depois da descoberta de que se ater a não cometer anti-patterns é muito mais importante do que se preocupar em desenhar soluções que acumulem o máximo de patterns possíveis, os frameworks e principalmente os desenvolvedores destes estão amadurecendo o suficiente para trazer a tão afastada simplicidade de volta. Parece que a coisa está se estabilizando, menos frameworks estão sendo lançados e os existentes (e até os poucos que estão saindo) estão recebendo um forte certo apelo para a simplicidade no dia-a-dia do desenvolvedor.

Como estou sempre cheio de livros e impressos bagunçados e misturados na mochila e na estante e algumas dezenas de workspaces misturadas entre o desktop e o notebook, resolvi passar para o blog as experiências com alguns frameworks Web que andei estudando e que trazem bastante simplicidade de volta, de onde nunca deviam ter saído. Irei pela ordem:

Comecei com o RIFE há bastante tempo, bem antes de pensar em escrever este post, quando ainda estava lendo a respeito do uso de Continuations. O RIFE não é um framework com a mesma proposta do Wicket ou Waffle (os próximos), ele na verdade é um approach para Ruby on Rails, mas que não deixa de ser uma proposta para simplicidade e produtividade =)

Depois passei para o Apache Wicket, neste aqui tentarei passar mais tempo, pois foi o que mais me chamou a atenção e o que eu mais gostei por diversos motivos que falarei no post sobre Wicket.

O Wicket foi incubado na Apache e em pouco tempo conseguiu ser “promovido” ao top level dos projetos, ficando agora no mesmo nível de Struts, Tomcat, Jakarta, o HTTP Server e muitos outros, vale a pena dar uma olhadinha.

E por último (pelo menos por enquanto) o Waffle, da Codehaus, onde o pessoal da Caelum tem colaborado. Com este ainda não consegui fazer muita coisa, então, certamente será o último post da série que irei apresentar.

Neste final de semana começarei então os posts com os exemplos de aplicação (para aprendizado) com o Wicket e RIFE, espero poder colocar uma a cada dia. Talvez a aplicação com Waffle demore dois dias ou três dias, o que pode fazer com que a análise comparativa de todas as aplicações saia só no próximo final de semana.

Code To Ruin

Já devo ter comentado em outras ocasiões aqui no blog que eu gosto muito dos posts do blog Worse Than Failure (antigo The Daily WTF). E essa semana saiu um post chamado Avoiding Development Disaster, um excelente artigo que fala sobre os projetos de desenvolvimento de software e as lições aprendidas nestes projetos, mas que muitas vezes gastaram milhões e milhões de dolares, geraram uma excessiva documentação inútil que nunca será lida por alguém e milhões de linhas de código que jamais serão executadas em produção, enquanto poderiam ter sido facilmente encontradas num bom livro de engenharia de software. O artigo mostra também os vários caminhos que os projetos podem seguir – tendenciosos ou não – rumo ao sucesso ou ao fracasso.

Avoiding Development Disaster