SF/JavaOne, Day 2, Netbeans Joy


For those who don’t know me, i used to be a huge Netbeans Nut.  I
used their tools when they were just in their infancy and was thrilled
at their rapid pace of developement.  Of course, in the past
couple of years the amount of Java coding that i do has fallen off a
lot, so i haven’t had the opportunity to really pay attention to what’s
going on with them.  Amazingly, they seem to have kept up that
sprinting pace of theirs without needing to pause or “Redefine their
vision”.  They also seem to be thriving in a highly competitive
java IDE space.  Eclipse, IntelliJ and Netbeans all seem to be
taking the best ideas from each other to create better and better
products.



Current awesome things that i’m seeing right now from them:

  1. Background compile.  This was one of those killer features
    that switched me over to Eclipse.  It’s now in Netbeans so i can
    switch back.
  2. Generics support.  Netbeans seems to have far better java1.5
    support than Eclipse does.  (and yes, i am referring to the latest
    bleeding edge drops of eclipse)
  3. Expanded refactorings.  I did try out several of their refactorings, and was pleased with them for the most part. 
    However, i tried a rename refactoring that changed the meaning of my
    code, and they did no verification of the rename to detect and warn me
    about this.  This makes refactorings highly suspect and dangerous
    and is definitely something that needs to be addressed asap.
  4. Expanded code assist tools.  IntelliJ is still king here,
    but netbeans is catching up fast.  This is one area where i really
    like what the competition is doing and we should be incorporating their
    great ideas into our own IntelliSense work.  For example, C#
    IntelliSense has an attitude of “we’ll assist you with whatever we know
    to be valid at this point, but no more”.  Whereas Netbeans seems
    to take the attitude of “we’ll let you type pretty much whatever you
    want, and if we can find a way to make it valid, we will.”  
    An example of this is typeing the name of a class that you don’t have a
    using/import for.  In C# we won’t help you type the class name,
    although we will offer to add the “using” after the fact.  In
    Netbeans, their quick assist will offer the class name for you (and
    tell you what package it’s in), and if you select it it will
    automatically add the “import” in for you.  Of course, this can
    mean that Quick Assist dropdowns get huge, but with smart filtering in
    Netbeans, and different quick assist windows in Eclipse, it means that
    it’s easily understandable and manageable.  I definitely want to
    experiement with different styles like this for providing code
    assistant in future versions of C# IntelliSense!

On top of this core support in the IDE proper, i’m seeing an enormous
amount of excitement and enthusiasm from other teams who are writing
plugins for this great IDE.  J2EE plugins, Profiling plugins, etc.
etc. etc.  I’m not sure how other people feel about that, but for
me, it’s not essential that hte tool come with everything out of the box



Ok.  Off to the pavilion now.  Will recap that later!



Comments (2)

  1. PDeva says:

    Could you give us an example of the rename refactoring that changed the meaning of the code?

    (And no, i am not a netbeans developer, just curious to know whether i screwed up my code accidentally while using the netbeans refactoring. )

  2. CyrusN says:

    PDeva: Sure!

    I’m actually going to do a blog post on this. So just wait and see.