Is it that good, nowadays? Long, long time ago in university (okay not that long, around 2006), I first discovered NetBeans as superior Eclipse replacement, but about a year later IntelliJ as superior NetBeans replacement. And this was already for relatively simple stuff.
Except performance. Saying this as a daily intellij user. I still miss incremental compilation speeds for Java that were in the order of milliseconds rather than the 5-10 seconds (minimum, if you are lucky).
I love Kotlin but compiler speed is not one of its strengths. And with the round trip via Gradle, it just is guaranteed to take multiple seconds to process even a 1 character change in a unit test when you run one.
Eclipse used to be awesome for this with Java:
- error state of your project would update in real time while you were typing. Introduce a problem, the project goes red immidiately. Fix the problem, the red goes away immediately.
- Edit, run, type, edit run type, etc. without noticable delay. Intellij never had this.
The reason for this was a deeply integrated incremental compiler. It could even tolerate compilation errors and still allow you to run parts of your code. There are not many IDEs out there for any language that can do that. IBM did that 20 years ago with Eclipse and it's a feature I miss a lot.
Same here, much prefer Eclipse to IntelliJ. Super fast and provides instant feedback on everything you do with the incremental compilation. And the workspace is amazingly powerful as a concept.
I used to bash Eclipse (Netbeans fanboy :) ), then IntelliJ came into the picture without Javadoc completion out of the box (fixed nowdays), required explicit invocation of inspections, ten finger chords, no incremental compilation, no support for JNI development, indexing non stop,... and I re-learned how great Eclipse actually happens to be.
Some time ago I heard of a website dedicated to hating eclipse ide, but google can't find it. By any chance do you know what it is? Sorry if this comment sounds like gaslighting, I'm just curious.
Mac. It's not an OS thing. And no, it's not a virus scanner or something silly like that. I've seen the behavior replicated on lots of machines; including laptops belonging to other people that claimed it was my setup that was the problem. You set it up right, you get about 2-3 orders of magnitude difference in performance between Intellij and Eclipse. It's just that people get used to it and actually seem to think five seconds is pretty fast. Trust me, I've heard all the excuses over the years. When you've seen 50ms, 5 seconds is an eternity.
There's a secret to kotlin compiler speed, and that's learning scala first ;)
And yes, the eclipse way of live embedded compilation to a classloader nested in the IDE process was awesome in more than one way. Probably an inheritance from its Smalltalk roots?
Netbeans > Eclipse > IntelliJ when it comes to working on multiple projects. I still see colleagues who have a separate IntelliJ window open for each project they need to work with because IntelliJ makes it so damned convoluted.
> I still see colleagues who have a separate IntelliJ window open for each project they need to work with because IntelliJ makes it so damned convoluted.
I do this on purpose, because it's much easier than having all in a single window. IntelliJ always gives you the option to have them in a single window.
The single window option from IntelliJ is a hack of sorts, the last I checked they have some notion about importing a module vice a project. I'm not sure why on earth you would want separate windows though when, say, you're working on multiple Spring Boot projects and a couple of library jar projects that all interact with each other. Switching back and forth from window to window seems like self cutting.
Agree completely that it's mind-blowing, it's my go-to tool when I do need an IDE (though I get most of my work done on emacs).
However, at my age, another thing that's mind-blowing is that this is now considered efficient. My first experiences with this was with (IIRC) was its predecessor, Forte for Java, and while I loved it, I remember it being a huge resource-hog. It's unbelievable to me how much computing power has improved to the point that something like NetBeans can be considered efficient (I don't discount their efforts in making it more efficient, but I think the fact we have more brute-force capacity these days certainly helps a lot).
Well, it's efficient if you compare it with the even newer (and even less efficient) generation of IDEs based on browser technology. Haven't used NetBeans in a while, but JetBrains are doing their very best to hide Java from you - their products come with their own (probably customized) OpenJDK so you don't have to have Java installed etc.
Around 10 years ago, when I was getting started with Android development, there was a plugin for that. I did try it first, but ended up going the official way with Eclipse.
Basically because IntelliJ had support for Play Framework projects and was getting weird errors in Netbeans for some reason.
At the time Netbeans seemed ( and was ) dead on the water so I invested a bit o energy and frustration to learn the IntelliJ ins and outs of operating.
Still, I think and maybe it's an unpopular opinion, Netbeans auto-complete was top-notch and more "intelligent" than IntelliJ's, also much lighter IDE, IntelliJ has to thank the silicon Gods for all the cheap available RAM and processing power.
Netbeans team made one very good decision way back that IntelliJ still comes nowehere near to competing with: Integration with the underlying build system (Ant/Mvn/Gradle). IJ frequently gets itself into some weird state where it becomes uncoupled (unhinged?) from the Maven POM and has to be manually synchronised. Netbeans essentially does not have any independent notion of dependencies or build system, so there's never a sync question.
This also means that NB is infinitely better at handling/managing Maven sub-projects/modules, where IJ is pretty much always lost and blundering about in the wilderness.
All that said, I do believe that the Netbeans project has more-or-less lost the plot. They're spending so much time and energy trying to provide a language-server thing for VSCode that their own project is falling further and further behind the curve.
You’re spot-on about Netbeans’ Maven support. If you need to resolve a complex dependency conflict, figure out where a transitive dependency is coming from, etc.; it’s trivial in Netbeans and all but impossible in IntelliJ.
Try the (free, or premium) tabnine plugin. It uses a ML model to analyze your codebase for patterns and suggest better-and-better autocompletion over time as your project grows--it works really seamlessly with the IntelliJ autocomplete--so, it only adjusts the suggestion list when there isn't a straightforward suggestion from IntelliJ's already.
tried doing some PHP work on it, it is very light weight & actually good. i tried moving around a few dockable windows and it almost looks and feels like intelliJ. it isn't as polished as intelliJ but it is slowly getting there.
on a side note, I have also noticed that a lot of programming language communities are likely taken over by intelliJ staff, your post gets shadow banned if you mention other IDEs.
If HN or some other forum is secretly infiltrated by Jetbrains staff, and they shadowban people mentioning other IDE's... then why does PyCharm seem like the #2 option (behind VS Code) in the Python community, and why does WebStorm seem even further behind in the Javascript and web dev world?
It just happens that IntelliJ is the market share leader for Java IDE's, followed by Eclipse (whose users trend older and corporate and less like to be active on forums at all). Developers are precious and toxic when it comes to their editor or IDE preferences, and often tend to downvote others.
I used netbeans in high school when I was learning Java. The WYSIWYG swing editor is really nostalgic for me and helped me a lot, I’m glad to see it’s still active. Netbeans was actually an extremely good editor at the time, it was as good as IntelliJ and better than eclipse (imo).
I guess it comes down to personal taste, but the Jetbrains IDEs don't look great either. It's pretty far down my list of priorities and I'm a happy customer regardless, but they're all kinda ugly, very Java fat client-ish.
It's not even the non-native look and feel (what even is a native GUI these days?), VSCode somehow looks better.
I was similarly sad the NB C++ plugin was switched to a "language-server and good luck" approach. I actually do look forward to the day that language servers become on par with formal IDEs, but today is for sure not that day
I wonder how much of the poor traction Apache products gain is a result of the extremely low quality websites Apache projects tend to have.
None of the blog that is linked here, Netbeans github page, and the official NetBeans website have a single screenshot of what the application looks like. If you compare that to IntelliJ IDEA's website, it's filled with screenshots accompanying a writeup promoting the feature displayed in the screenshot.
All those call to actions are the bare minimum I'd expect of an IDE, nothing gives a unique selling point.
> It highlights source code syntactically and semantically, lets you easily refactor code, with a range of handy and powerful tools.
That's table stakes. Otherwise it's just notepad.
IntelliJ has me scroll down the page, but I then get a breakdown of what USPs IntelliJ thinks I a developer would be interested to know about, like it's refactoring and code completion, that it has specific integrations for frameworks. Testimonies, and new features are listed on that page. Not buried elsewhere.
VSCode, immediately shows that it's USP, it's extensions ecosystem, in the screenshot on the landing page and then covers some other minor USPs in brief segments.
Even Sublime Text, updated once every blue moon when Mars is in retrograde, understands that showing off USPs and the developer experience is key.
Now I used Netbeans for years, but only because I was exposed to it in the university computer labs. I've only had to go back to it to fix a JavaFX app we got landed with, and I can't say I was too impressed at how well it integrated with maven, having to ditch out and use the command line to get proper bundled builds to work.
For Java development, I struggled with every IDE other than IntelliJ. It just seems to get more things right and can ingest and work with things like Gradle vs Maven, Spring Boot, decompiling 3rd party jars for debugging if you don't have the source, running a Windows UI driving a project that's inside WSL, etc. It's expensive, but worth it enough that I've paid for it when a company would not.
I mean, netbeans was on the ascent at least as recent as 10 years ago, but then intellij stole their thunder, and eclipse held onto a core userbase more so than netbeans did.
Heh…I remember attending a Java dev conference in 2006 where attendees thought the mention of using NetBeans for professional development was a joke. Like the presenter prefaced a statement with, “if you use NetBeans…” and he wasn’t able to finish the sentence over the noise from the whole room erupting in laughter.
It has literally been a joke for at least 16 years.
There are countless companies running bizarre internal applications written using the NetBeans interface builder and I know for a fact they will never migrate away from it. It's certainly the also-ran of Java IDEs but 'extinction' is a little hyperbolic.
Right before I came to the comments here I just failed in a search to find a summary of the most significant changes of this NetBeans version. This has happened to me on previous versions in the past as well - you have to either read the exhaustive list of changes on their github page, or get lucky and find some 3rd party blog that condenses it down for you. Why doesn't Apache write that blog themselves? Or have they and I just didn't stumble across it?
It's been a while since I've seen the name NetBeans! It was basically the Java IDE for a little while there, until Eclipse took over. Eclipse basically won because NetBeans used Swing for UI, and Swing was hot garbage back then -- the features were otherwise almost exactly the same.
Neat to see the project still hanging on, albeit pretty tenuously.
I remember it as Eclipse taking over from Forte 4 Java, then NetBeans trying to regain share with various gimmicks, culminating with a fancy GUI layout tool that would have been excellent if it hadn't been exclusive to NetBeans.
Ehe I've yet another perception, I remember eclipse was what everyone used in my circles back then, mostly because it was the ide used for university courses.
Then forte died of acquisition, forte for Java bombed and NetBeans took over some interesting "4gen" features, so like given a table he would go and create the whole crud in swing on top. For a while it seemed to grow strongly but then eclipse opening up rcp fagocitated all thick client projects and NetBeans was left to dry.
It was almost 20yr ago so the time line is fuzzy, but this is how I recall it.
It looks like ffj predates the NetBeans acquisition, but it's hard to tell without a definitive reference. I found the original URL above via the C2 wiki.
No, I think Eclipse won because multi IBM dinero for marketing (back in the day) while Netbeans was... just zese guys, you know. Yeh, later they got some Sun support, but initially it was just... open source?
Do we have any Netbeans users here ? It would be good to hear abit about the good/bad stuff (Thinking Java development mostly). How good/bad is it compared to IntelliJ ?
I use NetBeans, never used IntelliJ so can't provide a comparison.
Main reason that I use it is that Eclipse isn't built for the operating system that I use and is hard to port. I would like to see more modelling features in NetBeans, there are several free and commercial tools built on top of Eclipse, the documentation on XML stuff in NetBeans didn't match the implementation the last time I looked at writing a plugin myself.
I spent years using NetBeans, then Eclipse, then IntelliJ IDEA and Android Studio, and now back to NetBeans. The features that made me return were having full C and C++ support (at the time, now less supported) and super-easy remote debugging. Those features let me write, build, and debug a Java application that interfaced with a Linux kernel device driver on an ARM Kobo Touch e-reader. Neither Eclipse nor IntelliJ IDEA could do that so easily.
And as mentioned in another comment, the direct support for the Apache Maven POM can make life easier, without the messy import required by the others.
With the new Flat Look-and-Feel with dark mode and the generally much better font rendering in Java, it finally looks great, too. There was a decade-long ugly period, though, which was one of the reasons I was desperately seeking alternatives.
I used NetBeans for C++ dev as well. But I had to stop several/many versions ago. They hard-coded a bunch of C++ version stuff, and it stopped getting updated. So when C++ was updated, beyond that, I stopped using NetBeans.
I find it fascinating that there's so many Netbeans fans here on HN. Been doing software engineering professionally for 20 years now and ever since IntelliJ started becoming popular around 2005 almost every single dev I have ever worked with couldn't look at anything else. I've been through 7 companies and tens of projects and met a single Netbeans enthusiast.
These days Jetbrains is just a default option for C/C++, Rust (Clion), Python (Pycharm), Java (IntelliJ).
Wondering what's so specific about HN crowd that makes Netbeans so popular here.
NetBeans always struck me as the kind of IDE you would use to get things done in Java, as opposed to Eclipse which seemed to function as a portal into the vast and confusing world of Eclipse plugins.
But IntelliJ rules the (Java) world now, so they're both obsolete and redundant.
Back in the day I thought Netbeans rocked! Instead of the Lego-like assembly of plugins in Eclipse you got something that worked right out of the box (we're talking a 10-15 years ago and focused on Java/JEE/JSF).
I'm a long time NB user, I still use it as my daily driver.
The transition to Apache has been tough, but it's honestly amazing how well it does. The singular task of just "keeping up with Java" is load enough, much less adding on features. And, indeed, it doesn't have any formal sponsorship like it did under Oracle.
My singular nit with the project is that they rely a bit on external projects.
If there's one real power feature to NetBeans is that it's a first class Maven IDE. It works really well with maven.
Many of the "New Project" wizards are simply wrappers around maven archetypes.
But therein lies the rub.
Many of those archetypes are NOT "owned" or maintained by the NB project, they're 3rd party. You have NB maintained code designed to work with a specific maven archetype maintained by someone else.
I appreciate how the team doesn't necessarily want to be a domain expert in some specific aspect of the vast Java eco-system. But now you can't submit a pull request to the "team", you have to go to someone else who may, or may not, deem the request worthwhile.
So it causes a bit of friction of not having a single source of ownership to various features of the IDE.
Been out of touch with it, but, IIRC, NB's plugin story used to be pretty top notch (hot reload and all). Better than Eclipse and IntelliJ.
Geert W used to write a lot of good articles on doing cool and interesting things with NB, and user stories of how it was being used at different companies to build internal tools. Their GUI builder was pretty sweet too, IMO.
88 comments
[ 5.1 ms ] story [ 142 ms ] threadI love Kotlin but compiler speed is not one of its strengths. And with the round trip via Gradle, it just is guaranteed to take multiple seconds to process even a 1 character change in a unit test when you run one.
Eclipse used to be awesome for this with Java:
- error state of your project would update in real time while you were typing. Introduce a problem, the project goes red immidiately. Fix the problem, the red goes away immediately.
- Edit, run, type, edit run type, etc. without noticable delay. Intellij never had this.
The reason for this was a deeply integrated incremental compiler. It could even tolerate compilation errors and still allow you to run parts of your code. There are not many IDEs out there for any language that can do that. IBM did that 20 years ago with Eclipse and it's a feature I miss a lot.
Once you get used to it, instant incremental compile >> everything else ...
And yes, the eclipse way of live embedded compilation to a classloader nested in the IDE process was awesome in more than one way. Probably an inheritance from its Smalltalk roots?
JetBrains refuses to support it and points users to buy Clion instead.
I do this on purpose, because it's much easier than having all in a single window. IntelliJ always gives you the option to have them in a single window.
However, at my age, another thing that's mind-blowing is that this is now considered efficient. My first experiences with this was with (IIRC) was its predecessor, Forte for Java, and while I loved it, I remember it being a huge resource-hog. It's unbelievable to me how much computing power has improved to the point that something like NetBeans can be considered efficient (I don't discount their efforts in making it more efficient, but I think the fact we have more brute-force capacity these days certainly helps a lot).
Basically because IntelliJ had support for Play Framework projects and was getting weird errors in Netbeans for some reason.
At the time Netbeans seemed ( and was ) dead on the water so I invested a bit o energy and frustration to learn the IntelliJ ins and outs of operating.
Still, I think and maybe it's an unpopular opinion, Netbeans auto-complete was top-notch and more "intelligent" than IntelliJ's, also much lighter IDE, IntelliJ has to thank the silicon Gods for all the cheap available RAM and processing power.
This also means that NB is infinitely better at handling/managing Maven sub-projects/modules, where IJ is pretty much always lost and blundering about in the wilderness.
All that said, I do believe that the Netbeans project has more-or-less lost the plot. They're spending so much time and energy trying to provide a language-server thing for VSCode that their own project is falling further and further behind the curve.
It’s also slightly easier to (almost) fully keyboard-operate than IntelliJ, in my opinion.
Another thing I like is that Netbeans can open and work with Maven projects without having to “import” them.
on a side note, I have also noticed that a lot of programming language communities are likely taken over by intelliJ staff, your post gets shadow banned if you mention other IDEs.
If HN or some other forum is secretly infiltrated by Jetbrains staff, and they shadowban people mentioning other IDE's... then why does PyCharm seem like the #2 option (behind VS Code) in the Python community, and why does WebStorm seem even further behind in the Javascript and web dev world?
It just happens that IntelliJ is the market share leader for Java IDE's, followed by Eclipse (whose users trend older and corporate and less like to be active on forums at all). Developers are precious and toxic when it comes to their editor or IDE preferences, and often tend to downvote others.
It really is as simple and non-paranoid as that.
IntelliJ looks so much better than NetBeans or Eclipse
It's not even the non-native look and feel (what even is a native GUI these days?), VSCode somehow looks better.
In particular, a while back the default look & feel was switched to FlatLAF ( https://www.formdev.com/flatlaf/ ), and before that again we did a lot of work to support HiDPI and Retina screens ( https://cwiki.apache.org/confluence/display/NETBEANS/HiDPI+%... ). In NetBeans 15 we did a series of tweaks to further improve the look of the UI (e.g. https://github.com/apache/netbeans/pull/4286 ).
It actually works with current Java, but you have to edit a configuration file first!
I have no idea why they find that acceptable and still ship it in this state.
Don't tell me the sob story about the poor open source project. At some point the users' experience has to count, as well.
None of the blog that is linked here, Netbeans github page, and the official NetBeans website have a single screenshot of what the application looks like. If you compare that to IntelliJ IDEA's website, it's filled with screenshots accompanying a writeup promoting the feature displayed in the screenshot.
https://netbeans.apache.org/
yes it does?
> It highlights source code syntactically and semantically, lets you easily refactor code, with a range of handy and powerful tools.
That's table stakes. Otherwise it's just notepad.
IntelliJ has me scroll down the page, but I then get a breakdown of what USPs IntelliJ thinks I a developer would be interested to know about, like it's refactoring and code completion, that it has specific integrations for frameworks. Testimonies, and new features are listed on that page. Not buried elsewhere.
VSCode, immediately shows that it's USP, it's extensions ecosystem, in the screenshot on the landing page and then covers some other minor USPs in brief segments.
Even Sublime Text, updated once every blue moon when Mars is in retrograde, understands that showing off USPs and the developer experience is key.
Now I used Netbeans for years, but only because I was exposed to it in the university computer labs. I've only had to go back to it to fix a JavaFX app we got landed with, and I can't say I was too impressed at how well it integrated with maven, having to ditch out and use the command line to get proper bundled builds to work.
This is also probably a reflection that NetBeans is a project on fast path to extinction.
It has literally been a joke for at least 16 years.
https://web.archive.org/web/20160708090748/https://netbeans.... https://web.archive.org/web/20160708091639/https://netbeans....
Why did they waste time redoing it into something so useless is beyond me.
Neat to see the project still hanging on, albeit pretty tenuously.
Then forte died of acquisition, forte for Java bombed and NetBeans took over some interesting "4gen" features, so like given a table he would go and create the whole crud in swing on top. For a while it seemed to grow strongly but then eclipse opening up rcp fagocitated all thick client projects and NetBeans was left to dry.
It was almost 20yr ago so the time line is fuzzy, but this is how I recall it.
https://archive.ph/Qzllr
It looks like ffj predates the NetBeans acquisition, but it's hard to tell without a definitive reference. I found the original URL above via the C2 wiki.
https://www.developer.com/java/ejb/sun-forte-for-java-and-ne...
Main reason that I use it is that Eclipse isn't built for the operating system that I use and is hard to port. I would like to see more modelling features in NetBeans, there are several free and commercial tools built on top of Eclipse, the documentation on XML stuff in NetBeans didn't match the implementation the last time I looked at writing a plugin myself.
And as mentioned in another comment, the direct support for the Apache Maven POM can make life easier, without the messy import required by the others.
With the new Flat Look-and-Feel with dark mode and the generally much better font rendering in Java, it finally looks great, too. There was a decade-long ugly period, though, which was one of the reasons I was desperately seeking alternatives.
I've since progressed to VisualCode and CMake.
These days Jetbrains is just a default option for C/C++, Rust (Clion), Python (Pycharm), Java (IntelliJ).
Wondering what's so specific about HN crowd that makes Netbeans so popular here.
I use VSCode for most things, haven't tried the Jetbrains stuff much, besides in an interview where it worked "well enough".
Maybe eventually, I'll fork over and try the Jetbrains world. Maybe.
But IntelliJ rules the (Java) world now, so they're both obsolete and redundant.
Yep—Electron came along and made Java GUI programs seem trim and snappy. :-)
The transition to Apache has been tough, but it's honestly amazing how well it does. The singular task of just "keeping up with Java" is load enough, much less adding on features. And, indeed, it doesn't have any formal sponsorship like it did under Oracle.
My singular nit with the project is that they rely a bit on external projects.
If there's one real power feature to NetBeans is that it's a first class Maven IDE. It works really well with maven.
Many of the "New Project" wizards are simply wrappers around maven archetypes.
But therein lies the rub.
Many of those archetypes are NOT "owned" or maintained by the NB project, they're 3rd party. You have NB maintained code designed to work with a specific maven archetype maintained by someone else.
I appreciate how the team doesn't necessarily want to be a domain expert in some specific aspect of the vast Java eco-system. But now you can't submit a pull request to the "team", you have to go to someone else who may, or may not, deem the request worthwhile.
So it causes a bit of friction of not having a single source of ownership to various features of the IDE.
Geert W used to write a lot of good articles on doing cool and interesting things with NB, and user stories of how it was being used at different companies to build internal tools. Their GUI builder was pretty sweet too, IMO.
Glad to see it's still around!