I personally used NetBeans before Eclipse, but I never got used to it. As a Minecraft modder(yeah, worst way to start Java) I was "forced" to use Eclipse, since everything was already set up for it. I have now grown to Eclipse, and use Notepad over NetBeans at school since it's too different to Eclipse xD

By and large, Eclipse (and probably Netbeans, I wouldn't know for sure) take care of automatically building everything for you. You use Ant generally for the packaging sort of stage, and deployment, and distribution. When you're just hacking on stuff the built-in function in Eclipse does it all.

Cas

That's true, but if you want to do something off-the-beaten-track like sign jar files (for webstart deployment), you have to use a special xml ant script which takes a long time to nut out.

Also to download a project's source files and get it to compile and build, you need to run Maven which has its own special xml script. Why can't we just use java programming to do the download, the file placement, set the appropriate class path variables and then it's done.

Nate's Scar project (http://www.java-gaming.org/index.php?topic=25342.0) is the best solution that I've seen. But of course everybody is already using Ant to build their projects and Maven to distribute their open source code. So i still have to suffer the idiosyncrasies of these clumsy xml-programmed utilities Ant and Maven.

I work with eclipse at work and with netbeans at home for my personal projects. Guess what I prefer . IMO Netbeans is much more structured, eclipse is a plugin moloch to me. I love the way Netbeans integrates Maven. No additional ide files just the pom. For building stuff maven is a great help. Just use mvn appassembler and mvn webstart to deploy to any thing you want. It's a pity Google goes with Eclipse, but I think the main reason behind this are corporate hostilities. IntelliJ is on my plan-to-test-list. Its commercial nature bugs me.

None of Ant, Maven, SBT, or Gradle fit all the criteria in that article perfectly (mostly where it comes to simplicity and two of them don't integrate into IDEs), but I guar-an-damn-tee you that neither does Joe's Homebrew Build System that he wrote because the others were Too Darn Enterprisey. If you're going to write your own build system, one that just tackles the subset that is just your problems and not all the others in that list makes your build system a toy.

A build system is the first thing I have to deal with when I start dealing with someone else's code. It's your project's first impression on the developer. If my date starts the night off by insisting we speak in Esparanto, I'm pretty much going to call it a night right there.

I have to retract the statement I made almost a year ago. I used to use Netbeans... but I've recently started a new project using Eclipse 3.7 and I don't think I have a reason to touch Netbeans anymore. The IDE has become so wicked fast and the plugins have become nice and stable, it truly a pleasant experience to use it for just any kind of project.

And I go that extra mile to which will probably have people point their finger and laugh at me; I actually use a Mavenized project. Why oh why? Because I like controlling the settings through a simple copy/pastable configuration file plus the ability to automatically build the executable jar; the m2eclipse plugin takes care of keeping my Eclipse project nice and synced with the Maven configuration, plus it all hooks very nicely into SVN for those important backup purposes (my SVN repository is on an external harddrive).

My enterprise adventures have also bled into my game development efforts. I have actually created unit and system tests for important parts of my game code and boy does it help take the annoyance out of having to debug your code. I use TestNG for that because the Eclipse plugin is really, really nice.

From a noob's point of view, Eclipse is much better. It simply does the things you want the first time you click the button you think that would do that thing. With NetBeans you need experience and detailed understanding how Java works and why something might not work. NetBeans loads faster, and has a certail old school appeal, so if you are an experienced Java programmer and do only specific things that do not require plugins you might like that one better.

Are you basing that on personal experience like ra4king, or are there actual numbers to back it up? I've never really used NetBeans so I'm genuinely curious. Eclipse loads relatively quickly for me at home, but is relatively slow to start at work. Naturally, this is because of the complexity of the projects I'm working on at both places.

I'd imagine there are many factors involved in the startup times of both IDE's - the size and quantity of projects in the workspace loaded, the number of plugins installed, etc. The one that's faster out-of-the-box may not be faster in a "real world" scenario.

Startup time surely isn't as important as which one you're most productive in. To which everybody who's ever tried it says IntelliJ is the clear winner.

Eclipse loads really slow when you have a lot of plugins. Move it to a SSD and it zips again. IDEA is fairly pokey to load all the time. Netbeans is somewhere in the middle. But it's not like you need to start your IDE a dozen times a day.

From a noob's point of view, Eclipse is much better. It simply does the things you want the first time you click the button you think that would do that thing.

Both Eclipse and Netbeans solve exactly the same problems in exactly the same way. Either you do it by hand, or you use one of the many built in wizards. In comparison, Netbeans project settings have far less nuts and bolts as Eclipse does; it is more "noob friendly".

Quote

With NetBeans you need experience and detailed understanding how Java works and why something might not work.

That is the same with Eclipse or any other IDE. And no wonder, as you cannot do the job without knowing how it works :s

The tools is there to help you do your work, not to do the work for you.

There is some debate about what actually is "work" and what is just "wasting our time fiddling" though isn't there... like the whole way Eclipse (and Netbeans?) just automatically keeps everything compiled, all the time, and tracks all the errors for you - that's not "programming Java", that's "managing development", and that's what IDEs do - take care of all the tedious drudgery of development letting you get on with the very core thing you want to do: code.

There is some debate about what actually is "work" and what is just "wasting our time fiddling" though isn't there... like the whole way Eclipse (and Netbeans?) just automatically keeps everything compiled, all the time, and tracks all the errors for you - that's not "programming Java", that's "managing development", and that's what IDEs do - take care of all the tedious drudgery of development letting you get on with the very core thing you want to do: code.

Cas

Yes, very true that. But even the fiddly stuff you don't appreciate until you know what the IDE is doing for you

"build automatically" is what you are describing. Both IDEs are capable of doing that in the sense that you see compile errors as you type. Netbeans is slightly slower in updating the status and I actually like that; getting a compile error because I'm not finished typing is somewhat of an eye sore to me and I have more chance of experiencing that using the snippy Eclipse than I do under the slightly slower to react Netbeans I wonder if there is a setting somewhere I can change to make Eclipse less "in my face"...

There is some debate about what actually is "work" and what is just "wasting our time fiddling" though isn't there... like the whole way Eclipse (and Netbeans?) just automatically keeps everything compiled, all the time, and tracks all the errors for you - that's not "programming Java", that's "managing development", and that's what IDEs do - take care of all the tedious drudgery of development letting you get on with the very core thing you want to do: code.

Cas

Yes, very true that. But even the fiddly stuff you don't appreciate until you know what the IDE is doing for you

"build automatically" is what you are describing. Both IDEs are capable of doing that in the sense that you see compile errors as you type. Netbeans is slightly slower in updating the status and I actually like that; getting a compile error because I'm not finished typing is somewhat of an eye sore to me and I have more chance of experiencing that using the snippy Eclipse than I do under the slightly slower to react Netbeans I wonder if there is a setting somewhere I can change to make Eclipse less "in my face"...

Of course there is, there's a setting for everything! When I get home ill edit this post with where it is. For now Google is your friend

There is some debate about what actually is "work" and what is just "wasting our time fiddling" though isn't there... like the whole way Eclipse (and Netbeans?) just automatically keeps everything compiled, all the time, and tracks all the errors for you - that's not "programming Java", that's "managing development", and that's what IDEs do - take care of all the tedious drudgery of development letting you get on with the very core thing you want to do: code.

Cas

Yes, very true that. But even the fiddly stuff you don't appreciate until you know what the IDE is doing for you

"build automatically" is what you are describing. Both IDEs are capable of doing that in the sense that you see compile errors as you type. Netbeans is slightly slower in updating the status and I actually like that; getting a compile error because I'm not finished typing is somewhat of an eye sore to me and I have more chance of experiencing that using the snippy Eclipse than I do under the slightly slower to react Netbeans I wonder if there is a setting somewhere I can change to make Eclipse less "in my face"...

I don't mind if it's in my face a bit. error markers are a lot better than "error X on line number Y" and you've got to scroll to that line number. It's especially useful when i download someone's code and it has errors because i didn't set the build path right or something. the little red X's in the package explorer lead me right to the file, and i can click on the red marker on the right of the scrollbar and it scrolls right to it. most bloody useful thing ever.

I don't think gimbal was complaining about how errors are indicated as much as how quickly Eclipse identifies them. I agree it does seem a little fast, considering if you pause for even 1/2 second when typing a line, Eclipse will often eagerly inform you of a syntax error. I agree that it took a little bit for me to get used to it as well. But it's better than the old days, when you actually had to manually compile your code to see what you did wrong.

In fact I turn off nearly all the smart editor stuff in Eclipse because my ancient brain has been conditioned to them not being there. Rather like how autocorrect in Word corrects "teh" to "the" but unfortunately after my fingers have already started backspacing over it...

For people who do lots of software, I would recommend being comfortable with all three major Java IDEs: Eclipse, IntelliJ, and NetBeans. Different IDEs are generally better for different tasks, and as they evolve, they often leapfrog each other.

For Java projects, I used to really like Maven because I could trivially switch IDEs in the middle of development without any effort. Sometimes, I'd want to use a feature on another IDE, or I hit some weird problem with version control integration or something, and I'd jump to a different IDE as a fast workaround. Today, I find Gradle a more elegant build system than Maven for Java and Scala development. But I haven't been able to get Gradle to work with NetBeans like Maven did.

Also, I use different IDEs for different tasks. For example, I found a LaTeX plugin for Eclipse that I love, so I've been using that every day. I had to do a project in Python, and I tried a few approaches, but got IntelliJ working and ended up using that. For Scala development I found IntelliJ far better than Eclipse or NetBeans, although I hear the official Scala IDE support from TypeSafe is for Eclipse and that is progressing rapidly, so I'll give that a shot on my next Scala project. When I did a JavaFX project, NetBeans seemed like the only practical option.

Gradle's nicer than maven when you need to do something custom, but there's no real tooling support. For scala, sbt is the bees knees. No tooling support at all there to speak of, but god it's nice to have a shell window running "sbt ~test". And the unfortunately named "ls" plugin (https://github.com/softprops/ls#readme) makes dependency discovery a real dream and lets you avoid the nonsense of the ls.implicit.ly site (Scala culture appears to have been invaded by ex-ruby hipsters)

What tooling support do you need? IntelliJ has Gradle support but I honestly couldn't get it to do what I wanted.

Gradle will auto-generate IntelliJ/Eclipse project files which has been all that I need.

Also, I tried SBT a lot for Scala development, but I found Gradle actually much simpler. And I like Gradle is excellent at both Java and Scala projects and potentially more project types, while SBT is really only good at Scala -- they claim to be more, but realistically, it seems people would only want to use it for Scala.

What I like over my old command line approach is:- It auto-generates the .pdf every time I save, without me having to switch to a command prompt. It's also much faster than the command line.- Before, if I forgot to close the PDF file, I would get an error when running pdflatex. Now, I can leave the PDF open without causing a conflict and it automatically refreshes.

I've been using NetBeans for a few years and enjoying it. Recently I switched to Eclipse for a class project and I'm starting to prefer it.

I'm kinda bare-bones when it comes to using my IDE -- no fancy plugins, macros, Maven/ANT scripts, etc. Since both IDEs handle basic code editing and code-completion well, I tend to nitpick the smaller details. These are the differences I can think of that personally bug me...

Eclipse advantages:- Changing the main class in Eclipse is quick and easy; just open a new class with a main method and hit Run. For my coding style, this is way more efficient than going to Project Properties every time I want to run a new main class.- Import fixing is "smart" in Eclipse (and import code is nicely folded automatically). I don't need to select every time which conflicting class to import, since Eclipse generally remembers my last decision (whereas NetBeans doesn't seem to).- Linking with native libraries is super easy.- Responsiveness; I find NetBeans to be sluggish at times; and it loads way slower.- I generally feel more productive in Eclipse; maybe it's because compiler errors show up so quickly, Eclipse tells me when variables aren't used, etc. I haven't noticed some of these features in vanilla NetBeans.- Eclipse is smart at pasting code to the proper indentation level, i.e. pasting a block of code into a for loop

NetBeans advantages:- Exporting JARs on compile (and includes proper class-path in manifest)- Setting project-wide VM arguments- The file system is refreshed automatically; if I change my sprite sheet image I don't need to hit "F5" to refresh the project before compiling- Renaming, say, a class or method is more intuitive and doesn't fail like it often does in Eclipse

java-gaming.org is not responsible for the content posted by its members, including references to external websites,
and other references that may or may not have a relation with our primarily
gaming and game production oriented community.
inquiries and complaints can be sent via email to the info‑account of the
company managing the website of java‑gaming.org