Hacker News new | past | comments | ask | show | jobs | submit login
Apache NetBeans Proposal (apache.org)
144 points by aikah on Sept 13, 2016 | hide | past | favorite | 83 comments

Is it me or has Apache increasingly become the place open source projects of big companies go to die? OpenOffice, Geronimo, Harmony, Wave, etc.pp.

I really think that Apache should stop incubating projects which were essentially discarded by their corporate owners. Successful OSS projects are either community projects from day one (HTTPd etc) or require (at least initially) strong interest and involvement of the company that donates the code. How can you expect a community to magically develop around an abandoned project?

I am the project lead for Eclipse Che - developer workspace server and cloud IDE. The core of this project came out of Codenvy. Three years ago we were searching for the right governance model and community to open source Che from Codenvy.

We originally started with Apache. We went that way because we did not have relationships with Eclipse Foundation, the Orion project - a perceived competitor at the time - was already there, and concerns over IBM having an outsized dominance / influence over the community.

When we reached out to the Apache foundation to discuss the ways we could get our software into their foundation, building mentors, and also cross-project collaboration - we really struggled. We were unable to get the necessary endorsements. Apache was really bare bones governance. Because we couldn't get the right mentors, the proposal never made it out of an early proposal phase.

Serendipity at the time had me accidentally meat the Orion project lead at the Eclipse Foundation. Conversations ensued, and a path for how Che could come to be a reality with the support of other vendors that wanted to get involved was laid out. And that lead to our ultimate path into Eclipse and promotion there.

So this is an interesting back story about how one project ended up in Eclipse vs. Apache.

Interestingly, Eclipse is opinionated about the projects they promote. They are topically focused and work for project cross-pollination along with driving marketing initatives and IP policies around driving adoption of their core underlying projects. So that is a bit of a departure from the Apache approach where each product is more autonomous in terms of its underlying promotion responsibilities.

This plays a little bit to @dr_faustus comment on Apache being a place where many large projects are going - they can do that because the community already exists and they need the most structured infrastructure / process.

I'm curious to understand where to draw the line between the need for governance/bureaucracy versus just releasing code on GitHub and being a good participant (reviewing PRs, running a mailing list, etc).

Maybe whenever there are a dozen or so companies trying to create a business model so they don't fight each other too much? Has that ever worked with the high profile Apache projects that people remember here (OpenOffice, CouchDB, etC)?

There is a really interesting distinction between Apache and Eclipse around IP policy. It's taken me a good year of releasing with Eclipse to understand many of the nuances.

The biggest distinction is that Eclipse has an IP Policy where all of the code and assets has to have provenance of the code - either code submitted under a CLA, but if there are links to third party libraries, they are each independently reviewed by an on staff legal team. There are more details beyond this, but that level of human provenance review for every Eclipse project for it to be released, enables certain companies to more readily and easily adopt projects with not only an EPL license, but released as an Eclipse project with signed binaries on their hosted servers.

There are differences around mentoring, release process, hosting rules, infrastructure. But at the end of the day, it's about structure, rigorous rules, mentorship, and community.

Apache's IP provenance is also considerably robust and respected.

Thank you for sharing.

"...we were searching for the right governance model..."

I am very interested in comparisons of governance models. Case studies, war stories, analysis, whatever.

I joined a team working on OSS specifically to learn more about governance. The stewards of kuali.org were a consortia. It was a train wreck. Least common denominator consensus based decision making, layers of hierarchy, no accountability, paralysis and inaction, abundance of NIH / reinvention, etc.

Tellingly, kuali is now kaput.

Sadly, I didn't learn anything actionable about governance.

It would be a nice white paper to compare the development, release, IP, infrastructure and branding processes of the Linux Foundation vs. Apache vs. Eclipse.

I pick these three as they are foundations that have been long lasting and have proven an ability to retain member companies and a diverse set of projects.

The comparison would take a lot of effort to do but be worthwhile. You need to compare details as minute as around how web sites are hosted, how products are named, trademarking + copyright issues, provenance and IP policies around releases, mentorship, maintenance --- even things as formal as how issues are created, pull requests established, and how projects are organized among the committers.

The foundations can derive policy and rules at any level - and there is a significant variance depending upon the underlying charter of what the foundation is trying to promote. So the best place to start is the bylaws of each foundation, which are open source themselves, to understand the underlying motivation. Nearly all choices are made from the underlying principles.

Interestingly, the Eclipse Foundation is one of the larger revenue organizations from member contributions, but they do not have that many projects - maybe 300 or so. The IP provenance requirements are so stringent that many smaller projects turn away because they do not desire such a level of review. So the Eclipse Foundation is about to introduce a dual IP mode where projects can self-certify their IP provenance. The entire process around releases will be different can instead of taking weeks to make a release, could be done nearly instantaneously, allowing many projects that have a small group or open source license to become a project of the foundation, if that was a desire.

Apache doesn't have "member companies" -- it is governed by individuals.

Apache is also a 501(c)(3) charity for the public good -- as opposed to a 501(c)(6) business league like Eclipse and the the Linux Foundation.

One of these things is not like the others.

It is not you. If you look closely at Apache projects. They are mostly Java type projects in various state of completion. Some are either failed at corporates and hence dumped there (struts, cordova and so on) or too experimental and hence good place get wider audience. If successful the main sponsor will add proprietary features/components and sell product and/or support(e.g Hadoop ecosystem components).

Some exceptions to this are Apache Http server, tomcat, svn etc.

There are plenty of live and popular Apache projects that get plenty of press time: Zookeeper, Hadooop, CouchDB, Cassandra, Storm, Cloudstack, SpamAssassin, Lucene(! -- the guts of ElasticSearch), Spark, .. hell, the list is fairly endless.

Yes they adopt a lot of code (OpenOffice!) and weird abstract crapware, but this is not quite the norm. If you measure the success of the average Apache project, I'm certain it is vastly higher than any comparable organization, although I'm not sure who you could compare Apache to.. GNU?

Not much to disagree here. The success of Apache Http and Tomcat server will itself lift average success rate by quite a bit. Others if successful are mainly a vendor driven version of software.

> struts

Wasn't Struts a once-popular non-failure whose time has passed; rather than a corporate failure that was "dumped"?

I look at the project list and I think the great majority are not dead and abandoned. They are not the hottest list of tech but they are stable and used.

That's in part because the dead ones and the dump-ware are migrated by Apache to the "attic."

Apache is biased towards giving communities a chance.

Costs are low -- for about 200 projects, the ASF runs on a budget of around 1.4 million USD per year. It doesn't take that much to give a community a home -- the community itself is primarily responsible for making things happen.

People used to say that the surest sign of death for a project was to get a domain at Apache.org. This goes back at least ten years.

It's still the same... "OpenOffice, after years of neglect, could shut down" http://arstechnica.com/information-technology/2016/09/openof...

I sort of agree and see that trend but on the other hand some projects are flourishing on Apache.

My biggest gripe with the Apache community sphere is it is pain to contribute (I mentioned it here as well: https://news.ycombinator.com/item?id=11121563) and there is often interesting politics that develop on the mailinglist between developers. It seems when you start talking but "organizational" + "community" things some interesting behaviors happen (like who is the head honcho and who should we kick out).

On the other hand Apache does offer some continuity (in the event something happens to a lead developer) I suppose.

I was thinking the same thing. Many big open source projects are "entrusted" to Apache after their funding/support is cut off.

Why is Apache taking these up / wasting time on them? So far all of them have died shortly after, with no significant improvements landing once Apache has taken over.

> Many big open source projects are "entrusted" to Apache after their funding/support is cut off

Although "entrusted" to Apache, they're still controlled by the same people who change their titles from XXXX Project Manager at BigCorp to Apache PMS Chair for XXXX. These people are often the reason the project funding is cut off, and they'd rather keep control of a shrinking ecosystem than give up some control so the project can be saved, where they'd have a smaller share of a larger ecosystem.

Because the software still works and can be used by someone. Sure they might not be maintained and bug fixes wont happen. If the software does something that has no free alternative, the Apache one can still be used by someone for something to fill a need somewhere.

Yeah I know this is an absurd concept (to some) that someone might use older than a few year old tech.

Being an Apache project means(to me at least) that the product is ready to use and someone has used it before with at least some success. I trust a random open source product much less than anything Apache.

> Why is Apache taking these up / wasting time on them?

Presumably they get some funding in return. It makes $$$ sense for those entrusting if they have an established user base they no longer want to support.

The discussions and rationale for accepting any and all projects is done on-list, on the public Incubator threads. There are no "side deals" or "arrangements" other that was is opening and publicly discussed. In any case, any sort of quid-pro-quo about funding is NOT part of the equation.

I didn't mean there were "side deals" I just presumed that funding for Apache came from somewhere and this is surely somewhat from the organisations that donate technology. To say it's NOT part of the equation is naive at best, disingenuous at worst. Money is ALWAYS part of the equation.

Also a lot of projects succeed under Apache. NetBeans is great piece of software and it is not even remotely close to die.

"Is it me or has Apache increasingly become the place open source projects of big companies go to die? OpenOffice, Geronimo, Harmony, Wave, etc.pp."

It's just you :)

Seriously though, that is a mistaken impression, bolstered by people who have a vested interest in that impression. Instead, Apache is a place where large open source projects of big companies go to build an independent and healthy community around the project. Sometimes it doesn't work out, for numerous reasons, but most of the time the change is one of the best things to happen to the project.

Actually I think this is the way that FOSS projects are designed. If one group can't maintain it, another can take it over.

Netbeans was fine for a while and then better tools came out. I used Frontpage and Visual Interdev in the mid to late 1990s, discovered Netbeans later on. I remember downloading Netbeans with the Java SDK.

maybe, in fact, reading some of these comments it feels like they have quite the collection there at Apache.

But I personally find myself using Apache Lucene by way of Apahce Solr quite frequently. If we were a bigger organization I'd likely look at Zookeeper and Kafka as well. Alas the library market can be a small and depressing market.

Wasn't Geronimo and Harmony formed at Apache (and not donated by a commercial entity)?

Isn't Apache a community itself ? Should not it be left to the community to decide if they want to support that given project. Apache itself can abandon the project if there are not contributors.

You can add Groovy to that list.

Since Groovy has come to Apache it has thrived, though.


The Groovy download numbers have been infamously inflated [1]

Besides, most Groovy downloads come from Gradle. Hardly anyone starts a new project with Groovy, it's become a niche language used exclusively to write build files.

[1] https://news.ycombinator.com/item?id=8107241

Nowadays if you check bintray for Groovy downloads, virtually all of them come from Germany, which is where the server hosting the groovy-lang.org site is located.

Gradle 3.0, which came out last month, has replaced Groovy with Kotlin as its prefered choice for writing build scripts and plugins, so expect Groovy's use for build scripts to decrease.

I think Groovy will live long for scripting on the JVM, in the same way Bash is used for Linux. All the extra cruft Groovy bundles (e.g. MOP, static typing) will become irrelevant over time.

"People only use groovy to get shit done" is not an argument in favor of groovy dying.

Arguably, it's not where open-source projects go to die, but rather, where we send projects that should die, but we're just not ready to let them go.

The license will be changed to Apache License and this is great.

What I'm wondering is if they will succeed in keeping it very focused monolith as it is now, or some "design by commitee" will make it buggy monstrosity like Eclipse.

Exactly. I no longer use an IDE unless I have to (mostly a vim person), but if I were to choose one I'd take Netbeans. It's always been the most "put together". Easy to install, very focused, and the layout just makes sense. Despite my preference of non-JVM for execution (mainly b/c I go for performance vs. ease of coding), I like that Netbeans basically can run with almost identical look and feel on almost any platform with a functional JVM. I was always impressed that they were able to get the GUI to feel the same cross-platform, which even on Java isn't always easy to do. I hope Netbeans is able to keep its mojo intact. I was worried about the Oracle custodians...and now we might have to worry about a committee which could be just as dangerous.

Have you ever used IntelliJ IDEA? It seems to meet all your requirements: it looks and feels identical on all platforms with a JVM, it's very focused and "put together", and the layout just makes sense. In fact I only mention this after spending the last month trying out all three (Eclipse, NetBeans, IDEA) and settling on IDEA for these reasons and a few more (especially how it indexes the whole universe and gives you smart autocompletion in every place imaginable). And the Community Edition is free, if price is a concern.

Having used both NetBeans and IntellIJ, I greatly prefer NetBeans. What drove me up the wall with IntelliJ was the poor Maven integration.

Maven projects are first-class citizens of NetBeans, which means that NetBeans can read POM files as NetBeans project files. NetBeans generates a small supplemental file (nbactions.xml) to cover the few project-related things the POM doesn't store (such as the name of the default main class or the path to the JVM), and it duplicates no information. IntelliJ, on the other hand, uses its own project format exclusively, it duplicates everything, and the IntelliJ project file regularly falls out of sync with the POM and has to be re-synced, which can be a nightmare.

At the company where we used IntelliJ, I ended up just using IntelliJ as an editor, and I did all my building by executing mvn on the command line (and we, as a company-wide thing, never ran projects in IntelliJ: we had special scripts for that). And the only reason I used IntelliJ there was because our coding standards were defined as an IntelliJ config file; if not for that, I would've just used NetBeans.

IntelliJ might be a better editor than NetBeans, and that's debatable because NetBeans is also a really good editor, but I simply cannot stand using IntelliJ for anything other than editing, while NetBeans handles non-editing tasks beautifully.

"Having used both NetBeans and IntellIJ, I greatly prefer NetBeans"

Me too, even for C++. Wish it had Dlang integration too.

IntelliJ IDEA is the undisputed leader.

One of the big differences with both NetBeans and Eclipse is that it's commercial software with nice non-paid offerings. But, for example, for my project Community Edition is not an alternative due to lack of JSP editing. NetBeans is great for editing JSP.

Other shortcomings of Community Edition are survivable. In my case this is Google App Engine support that with a lot of manual configuration can be made to run and debug in Community Edition.

Honestly, I find that IntelliJ isn't anything particularly special. Yet another tool for warezd00dz. It is fadware.

Fadware with plugins. Plugins, upon plugins, upon plugins, upon plugins.

How exactly do you define fadware? My guess is anything you decide to denigrate since there is nothing in the definition of "fad" that applies to IntelliJ, but clearly you may have some other personal esoteric definition in mind and I am curious.

I regularly use PyCharm and CLion, but I still prefer Netbeans over Eclipse and IDEA any day of the week for Java development. A big part of that is that the maven integration is nicer, and I get along well with the debugging and profiling.

Same here: I can get an IntelliJ license any day I want.

I mostly like Jetbrains, I just prefer Netbeans for the UX and Maven integration.

I mostly use NetBeans (version 6.9 because Python - and love it) or vim. I always wanted to try IntelliJ out but never got around to it, so I was fairly disappointed when I started using Android Studio for a mobile app. Granted, it is light years ahead of Eclipse, but that's a very low bar to clear... I loved the search preview (fast and clear), but everything else seems much better in NetBeans. It's also quite slow on moments, but that could be because of Google additions. Would I like PyCharm any better?

Try the Pycharm Community Edition and see for yourself. I've found it to be one of the most comfortable environments to work in.

I was truly surprised by the code inspections (the "linter") and the depth of code analysis that it does. The first community edition would get stuck on some weird constructs from time to time, but every update improves upon it and I haven't seen the 2016 edition to have any issues with the weirdest code I have to maintain.

And the Community Edition is open source. It is fun to git clone the source and build it yourself - at least fun to do it once :-)

NetBeans was the first IDE we used in college (circa 2006). It's ridiculously easy to get setup, as opposed to Eclipse which I've always disliked.

Me too. I think eclipse is too complicated for a college student who's just upgrading from text editors or BlueJ. Netbeans is still my go-to IDE for prototyping stuff or writing simple stuff that dont need me handling multiple branches at once. The only reason its not my main IDE is the lack of workspaces and/or multiple instances (I did make it work once but its too tedious to set up again).

One of my favorite analogies is that Netbeans is the iOS of the IDEs and Eclipse is the Android. Eclipse supports way fore features than Netbeans but Netbeans "just works".

I have always felt NetBeans lagged behind Eclipse (and Idea) under Sun and even more so under Oracle. I think transferring to Apache would be a good thing overall for the NetBeans project.

I personally enjoy NetBeans more than Eclipse or any other Java IDE. There is something about Eclipse interface I just hate. But it always felt "less pluggable" and harder to customize than other prominent IDE. But it looks like it will definitely loose momentum without any real corporate support.

All in all, languages "shouldn't have IDE". They should provide services as separate apps that should be pluggable and used in any editor. That's something Go did well as it provides a code completion server and code quality tools and any dev can make a plugin out of them for any editor.

It makes things easier to develop and maintain for service developers, plugin developers and IDE developers.

I would love to be able to use Netbeans features without using Netbean itself, without being tied to the IDE.

There's actually now a common specification for language services (pioneered by Microsoft for Visual Studio Code), and Red Hat are implementing it for Eclipse:


I don't whether anyone is working on this for Netbeans, though.

Codenvy has added it into Che - shipping in a few weeks. Red Hat is adding it into Eclipse. And IBM is adding it into Orion. There is collaboration from Microsoft, Mulesoft, Salesforce, Zend, IBM, Red Hat and Typefox around the language services and proposal.

The big piece that is missing is a language server registry so that any tool can discover, install and register locally a language service. That will come next.

> The big piece that is missing is a language server registry so that any tool can discover, install and register locally a language service. That will come next.

According to the link:

> Language server registry: Language servers are published as part of a global registry, built by Codenvy as an Eclipse project and hosted by the Eclipse Foundation, to make language servers discoverable for any tool to consume.

Sounds pretty cool. It's certainly a sad state of affairs when we look at existing projects like http://editorconfig.org and see that it only really covers indentation; we programmers should be those most able to configure and improve our own tools!

I really think there's a lot of low-hanging fruit for improving the programming workflow, and I think it begins by decoupling basic functionality like this from the monolithic IDEs they've traditionally inhabited.

We're able but we don't do it, since there's a 9 to 5 job with a manager that always screams we work to slowly, and then after work we have to pick up kids, do the dishes and what have you.

Didn't Steve Yegge talked about something like this a couple of years ago [0]. This is sort of a version of that. A fantastic thing if this really gets going. Surprised that this is the firsts I'm hearing of this.

[0] https://plus.google.com/u/0/110981030061712822816/posts/KaSK...

Not really.

Eclipse doesn't have a nice Swing/JavaFX UI designer like Netbeans does, EMAT isn't a match to the Netbeans profiling tools and the web tooling from Netbeans allows workflows not possible in Eclipse.

For example when editing JSF files you automatically get completion to the session beans, or JavaScript code. Editing JavaScript code takes into account the JSLint documentation and besides completion there is static analysis taking place as one types.

Eclipse has WindowBuilder[0] that can be used to design Swing/SWT UIs (no JavaFX AFAIK).

[0] - https://www.eclipse.org/windowbuilder/

I know, but it isn't as feature rich as Matisse.

Netbeans runs on anything with a JVM, Eclipse is a lot harder to port to different systems.

Time to buy some JetBrains stock..


If anything Netbeans should be more attractive if it is released from Oracle.

> If anything Netbeans should be more attractive if it is released from Oracle.

Until the community around it solidifies and proves that it is committed and capable, it will probably be less attractive than when it was backed by Oracle.

The license changing to Apache is probably a good thing in the long run. The committer list in the proposal is roughly 1/3 Oracle. One can only hope they continue to be committed to it. It is certainly an ominous sign for the Java community in general that the designated steward is divesting tooling.

I think Oracle is disappointed how their ownership of Java is not as powerful as hoped though costing them a lot. The tooling and enterprise workflow probably eats a lot of manpower.

Netbeans was always great for the more advanced Java platform features since it was "officially" supported and often the demo implementation for them.

I hope Oracle will continue invest in it because it is a polished platform. The profiling and sampling tools shared with visualvm are awesome.

Or maybe Oracle is just loosening the governance grip on the platform allowing some control for other organisations invested in the platform.

Time will tell.

Good news overall, at least with Apache the project stands a chance of continuing. Oracle has shown to be a poor manager of open-source projects.

Maybe we can even get a proper Python plugin out of this ;-)

This worked out well for OpenOffice.org, Cassandra, Wave, Groovy...

Oracle transfers their software to the Apache Foundation: what could possibly go wrong?

What are you referring to?

Surely to Apache OpenOffice, which hasn't yet built a strong development community under the ASF's umbrella.

The thing with OpenOffice is that (mostly) everyone abandoned it for a better governed fork long before it got handed to the ASF.

"Yet". I'm sure it will... just give it more time

How much are you thinking? That is, at what point is your claim testable?

I think that highly unlikely. Hey can't fix their build process, how do they expect to get new contributors?

Presumably that Oracle will sue them for patent infringement several years down the line when the claimed damages is far higher.

Apache should be fairly experienced in ip law matters.

It is one of the reasons why being part of Apache is attractive to projects.

The patent provisions of the Apache License 2.0 address the possibility of submarine patents.


An entity which contributes to an ALv2 project and then sues over a patent which reads on their contribution loses the the patent license grants from other contributors, effectively locking them out of the project.

Oracle is likely to sue the users of Apache Netbeans, rather than Apache itself, and The ASF will not be in a position to do anything. After all, Oracle is on the record for sueing Google for using an Apache project (Apache Harmony).

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact