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).
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.
JetBrains refuses to support it and points users to buy Clion instead.
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.
This is also probably a reflection that NetBeans is a project on fast path to extinction.
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.
yes it does?
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.
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.
IntelliJ looks so much better than NetBeans or Eclipse
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's not even the non-native look and feel (what even is a native GUI these days?), VSCode somehow looks better.
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.
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.
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.
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.
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.
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!
But IntelliJ rules the (Java) world now, so they're both obsolete and redundant.
