What really frustrates me about how (I assume Oracle) handled this transition away from java.net is that all the issue links just lead to the same "java.net is closed" page, they didn't bother to redirect them to the github issues pages (the issue IDs are the same from what I've seen).
I run into this issue often enough that I've been tempted to write a userscript to translate the java.net links automatically... doesn't do anything about all the broken documentation links though :(
Yep. The closure of java.net broke jvisualvm for me; none of the in-application plugin links work. Instead you have to go find the new jvisualvm page and download it separately.
So Oracle fired off almost all the rest of the Solaris engineers, they are moving Java out of house, what's left from the original Sun purchase? SPARC? I see they still sell SPARC servers, but without confirmation from someone that they've somehow kept competitive with Intel (which they were having problems doing over a decade ago), I'm wondering if this is just a cash grab from people that don't know what they're getting, or are somehow forced to run software precompiled for SPARC (although gouging customers like that would fit my preconception of Oracle, accurate or not)..
It sounds like all their Sparc hardware folks have been laid off, too. Most news stories seem sketchy about the details, but there are posts like this:
interesting - the members are a mix of people from around the world, including Oracle India (just as is Amazon India or Google India or Microsoft India).
Time to invoke SandGorgon's law of outsourcing analogies -
"As an online discussion about PROGRAMMING grows longer, the probability of a comparison involving outsourcing or Indians approaches 1, if Godwin's law has not already been satisfied"
J2EE was designed for an era when big, monolithic entities were creating most of the production-grade software out there, SMP hardware was extremely expensive and capital-intensive, and open source software was largely considered a joke by those with the buying decisions. It made sense to try to target large entities that have developed decades of abstractions supposedly meant to reflect how complex (perhaps complected?) their business layer logic is and that their software architecture should be tightly coupled to it as such.
J2EE became a target for offshore software projects primarily because of its userbase being organizations that are fundamentally not software companies and that are constantly trying to cut costs while being unable to migrate off these systems quickly simply due to their sheer organizational inertia. These companies culturally haven't scaled based upon much more than bodies (a typical enterprise M&A is fundamentally more bodies and access to specific customer bodies rather than a strategic technology play given how slow M&A works in practice), and these are oftentimes the companies you see in newspapers that are experiencing business difficulties - what skilled, talented developers want to stake their careers working on software used only by a community that is in a multi-decade crisis?
Even if you spend a lot though, outcomes are not necessarily great either. US DoD is a great example of tons of J2EE on their backends with unremarkable outcomes despite having spent perhaps more dollars on software engineering effort than probably Google has in the past 30 years cumulatively (where the money goes is another topic).
It's tough problems as a large company that thought they were getting ahead of the technology curve back in the 90s and are now the dinosaurs and fossils.
To me the beauty of JEE on the backend is:
1. Scalability - the application server creates as many instances as needed - until it hits either the JVM limit or the machine limit.
2. Declarative transaction management so I can write reusable code that interacts with the database without having to worry about transaction boundaries.
3. Excellent and portable Object Relationship Mapping (Java Persistence Architecture).
On the front end, with JSF webpages can be developed very quickly.
There are a lot of other things you get with JEE like Asynchronous Messaging (JMS) - built in.
There is a reason mature organizations worth billions of dollars and with highly skilled architecture teams have settled on JEE as the defacto standard for their information systems.
There is definitely a learning curve with JEE, and someone fresh out of school will need a year or two to really understand how it fits together - but when you write something in this framework, it is easy to read, maintain and rarely needs to be re-written.
Most importantly, the framework will continue to be developed for the foreseeable future - I mean multiple decades.
On the other hand, some of the newer javascript stuff - is horrible broken spaghetti code that is glued together by spit and prayer. 99% of these frameworks will fall out of fashion with the associated problems that come with falling out of fashion - the canonical example being Ruby On Rails.
You're looking at this ecosystem after we've already gone through multiple versions of EJBs that are all very different from each other, several different JMS implementations from many vendors now deprecating them (IBM is deprecating a couple of their JMS implementations for cloud services in favor of a hosted Kafka offering, for example), and the endless XML-based configuration of all services and their components combined with a lot of tight coupling requiring different services to be re-deployed upon updating their EJB entities or face class unmarshalling problems. I'm not a fan of sloppy configuration, but there is historically far too many things that were necessary to configure to get a basic JEE service started.
A lot of what's in JPA now came after Hibernate became such an industry-wide standard and because EJB 2's EntityBeans were so awkward. For early adopters in the 90s, EJB 1.0 was really, really difficult to work with and overall a frustrating experience compared to using Spring + Hibernate. This pain was much more keenly felt for enterprise software start-ups that couldn't afford release cycles and deployments that take so much time.
JMS is not the end-all be-all of enterprise messaging either and the J2EE ecosystem made certain technology innovations more difficult due to its byzantine nature. The AMQP working group came out of their frustrations with JMS and it includes a lot of experts with JMS implementations from the usual vendors.
I challenge you to find communities of developers other than H1Bs, older, offshored, and other disadvantaged (and in no way technically deficient either!) workers that are writing anything with EJBs for their jobs these days. Look at the career possibilities for these places as an engineer - do you imagine IT outsourcing and banking backends is something highly motivated and talented engineers would find fulfilling when there's other options? Furthermore, I challenge you to find operations teams that enjoy supporting these systems compared to architectures built around microservices / SOA using lightweight containers using, say, Kubernetes. J2EE architecture is simply not easy to maintain in production with typical enterprise sysadmins despite the billions spent on improving them over multiple decades now (and due to the hostile atmosphere of enterprise software vendor-client relationships impeding technical progress since time immemorial), and this is a deal-breaker for large organizations that are trying to reduce operations costs.
Even though ultimately we as an industry seem to be reinventing the wheel constantly probably to keep ourselves busy rather than to build highly maintainable software, this is preferable to millions of developers around the world in a monoculture writing constantly refactored and improved COBOL and Fortran if we approached the world of software with the JEE vision. It's been shown academically that for software reliability and maintainability, if you need to rewrite more than a certain percentage (I believe it was around only 30%) of the software, it is more economical and practical to rewrite it all. It is the rigidity of the JEE vision and competing enterprise standards that made interoperability and thus freedom for motivated, creative developers difficult that pushed them away from both larger companies and toward smaller companies united by open and probably less stable ecosystems. Moreover, it is really difficult to argue that the MIT Approach [1] fits everywhere in the software world and also that there is no merit to Worse is Better.
It's funny that you mention RoR in that there's been some concern by the community that it's becoming more like J2EE. It's a bit sad in a way because if everyone writing mature software winds up ultimately implementing J2EE, it has shown how little progress we've made as a software community despite so many different software design philosophies gaining market traction.
Once you get out of toy frameworks that won't scale, refactor or "age well" - you end up with a JEE style framework.
It's like that famous cliche about unix - "Those who do not understand Unix are condemned to reinvent it, poorly."
You are right about older versions of JEE being a pain in the ass to use - but that critique hasn't been valid since 2004 when EJB 3.0 was released - 13 years ago. JSF is really slick for front end development.
But even prior to the release of EJB 3, can you name any EJB equivalent (from the pain in the ass xml era) that is still used, supported and actively developed?
We literally still have 15 year old EJB's - that "just work". People just inject them into the new EJB's they write and they work!
You might think rewriting services to keep up with the latest and greatest fad is a productive use of your developers time - but I prefer to have my developers focus on solving new - revenue generating problems, with building blocks that have already been written instead of constantly reinventing the wheel.
We have a mix of American developers (junior, mid-level and senior), offshore developers in 6 countries, and H1-B developers - all of whom are paid at or above market rate for their work (150K+ for the State side workers). I don't think any one of them considers themselves "disadvantaged" in any way because of the technology stack.
They understand that they have problems to solve and JEE are a tool to solve their problems and I am sure they grateful we aren't making them re-write 15 year old code to keep up with the latest fad.
" what skilled, talented developers want to stake their careers working on software used only by a community that is in a multi-decade crisis?"
What multi-decade crisis are you talking about? Not everyone is hipster afraid to learn abstractions or unable to comprehend them. There is learning curve to J2EE and especially early versions were hard to learn, but willingness or ability to learn is not exactly mark of no-talented developer. Low skilled untalented developers go for easy to learn technologies.
Integration projects are difficult for many reasons, technology choice is not one of them.
I guess someone does not liked to hear that. I still find the "I was unable/unwilling to learn technology x, it is too complex for me, therefore I am superior" logic completely illogical.
The crisis is primarily that many J2EE projects are fundamentally cost center projects designed to be written once and maintained by a low-cost team and are thus focused more upon compliance to standards and consistency than creative problem solving. If a business domain is well understood and documented, it is very straightforward regardless of software platform to codify its rules and conventions - this is not what happens in most software developed today. The culture in the J2EE community (that does have value, not devaluing the approach) along with its participating community of typically old, established companies with cultures not favorable to certain personalities (regardless of skill) has caused a huge brain drain from making usability (and therefore consistency IMO) improvements that could have been possible. It'd be really interesting to see what would have happened if half of Silicon Valley's engineers contributed to the J2EE ecosystem, but we will never know given the trajectory of the industry.
From my years doing integration projects for a lot of the F500 I've confirmed your assertion that technology hardly matters for them, but this makes it very difficult to grow as a developer because you're not solving technical problems anymore as much as business level ones. The "learning" involved at technical levels tends to become more about trivial (API inconsistencies from implementation, names of properties) or specific, proprietary knowledge gained from basically reverse engineering other parties' code. This also does not require any skill or much training either. Combined with mostly straightforward coding requirements, this drives down the skill level necessary to be successful in a usual J2EE software shop and thus the labor pool drives toward commoditization.
I don't either, but I'm also wondering what the point was? There's ways that can be expanded that prey on stereotypes, and ways it can be expanded that don't, and the latter might have been an interesting discussion (e.g. India's growing population of software developers trained on Java, and whether that should garner them more influence of Java, and how that might affect it going forward as just on possible example).
By this Oracle now admits in times of Cloud, docker containers etc Java EE is relic of past and not of much relevance. Surprisingly though, Spring with its habit of adding a thick layer of crap over any technology is doing okay and lot of people seem to like it.
What would the Hillary Clinton of software companies be?
- Loses easy wins, blames everybody else
- Attacks minorities who point out her people are abusers
- 'Screws up everything with hubris' to quote Colin Powell
I never quite understood why a mention of Donald Trump needs to have a comparison of Hillary Clinton along side - and for that reason anyone? He is a vile and despicable human being and the fact that a big fraction of US voted for him doesn't change the fact. So we can criticise and ridicule him at every step without having to qualify it by mentioning every disliked person in history of humanity.
Because when it came down to it, the choice was between Donald Trump and Hillary Clinton. Clinton is also a vile and despicable human being, and the fact that a big fraction of the US didn't like her opponent doesn't change that fact. We can criticise and ridicule her at every step without having to qualify it by mentioning that somebody is subjectively "worse."
It's not "open season, but only for Trump" just because you like Clinton better.
Upvote for illustrating my point. In your universe there are 2 mutually exclusive and exhaustive groups - Trump people and Clinton people. I couldn't care less about Clinton. Go ahead and make fun of her all you want. My issue is with coupling of the personalities. When you retort to a comment about Trump with the 'oh but Clinton' defence you're trying (poorly) to take away legitimacy of individual criticism.
'When it came down to it' - well it comes down everyday. You have an option to not defend an immoral human (very objectively immoral, by the most basic of human moralities accepted in most civilized cultures).
How is this just happening now? Java is super popular in the open source and academic communities, but C# has been ahead of them since its start with an open specification, open implementations, and for the past few years, a full-throttle open source effort.
You're mistaking Microsoft's purely reactive strategy to something like real planning and commitment to open source. MSFT has been pushing into that area (sort of) recently because they kept getting their lunch stolen by all of the open source technologies out there.
Do you think it was anything but the most incredible terror and desperation that drove them to add a Linux subsystem to Windows? To open source their "crown jewel" of .NET? To support Linux on Azure? To make Visual Studio almost entirely free? To adopt Electron as the base for VS Code? To ditch TFS for GitHub?
Edit: Corrected to be more precise Chromium vs. Electron.
It's funny how software developers have no problem whatsoever dealing with complexity, except when it comes to corporate behaviour, when they are unable to conceive of a company as anything other than a single, gestalt entity, with a single opinion and purpose, whose actions are driven by the most basic emotions and can be classified as good or evil with absolutely no grey-area.
In the real world, companies are made up of lots of individuals, all with strong, differing opinions. Some people at Microsoft undoubtedly hate open source. Some of them undoubtedly love it. Many of them are probably, like most developers, somewhere in-between. They have no ideological investment, they just make use of it when it's useful.
Having actually worked in the Microsoft ecosystem in past, I know that there have been people there for years who like open source, and who have pushed to make Microsoft a more open company. There's no doubt that competitive concerns have driven some of Microsoft's embrace of particular open source technologies, but to characterise their entire approach to open source as being: 1) entirely recent, and 2) completely fearful and reactive, has no basis in recorded fact, and does an appalling disservice to the many people who have spent many years (successfully) trying to change Microsoft's internal culture and make it more friendly to open source.
> completely fearful and reactive, has no basis in recorded fact, and does an appalling disservice to the many people who have spent many years (successfully) trying to change Microsoft's internal culture and make it more friendly to open source.
If you're not already familiar with the "Halloween Documents" (https://en.wikipedia.org/wiki/Halloween_documents) then you should take a look. They were pretty much the definition of "fearful and reactive".
Microsoft has historically had an ideological investment in killing everything that wasn't Windows.
Microsoft has been roused in this fashion 3 times before that I can think of.
1. The internet. If you don't remember, MSFT completely misjudged the importance of the internet. A heroic effort by Bill Gates turned the company around and got them on track to seize control of the web (until Google drove them back).
2. Java. It was so successful that MSFT had to create a nearly identical tech stack that they controlled, after Sun beat them in court.
3. Linux. Open source, well supported, loved by tech people, runs on almost every conceivable hardware platform. It's been a herculean effort just to fight for market share. If it weren't for lock-in, MSFT would have gone the way of Solaris and HP-UX.
Now open source is the only way to try to get back that developer mind share that they've been losing for so long. This is a good thing in the long run, but to couch it as anything but "fearful and reactive" is to discount a lot of history.
>they are unable to conceive of a company as anything other
>than a single, gestalt entity, with a single opinion and
>purpose, whose actions are driven by the most basic
>emotions and can be classified as good or evil with
>absolutely no grey-area.
Seems like quite a straw man argument, there probably isn't a single person that actually fits your description. And it certainly does not describe a typical developer.
As infamously documented in "The Windows Shutdown Crapfest" [1], in order for anything to be publicly observed outside of most large bureaucracies, a large number of people are involved, and their only common interest comes from very high up in the bureaucracy. So you usually do end up with a single, simple ideology presented to the public, even though there are a lot of people internally fighting for different things.
You're not wrong, but you're not sufficiently right yet. You are saying that folks see only the forest, but you want to point out that there are lots of trees. Open your eyes: There are trees and forests.
A corporation has a power structure which necessarily is independent from any one person. It follows that there is something about corporations which is distinct from its employees. Look at a business as both having employees, who are people, and being a corporation, which is like a golem.
Well, maybe he is not talking about those people, but about the decision makers.
And those strategic decision makers (a rather small community) dont love open source.
Yes, even the new generation.
Nobody does risky moves out of the sheer joy of doing them, especially if you have shareholders holding the Damocles sword of share-value over your neck.
I think a lot of people get into software because they dislike complexity and code gives them the opportunity to tackle it. You can't "solve" the complexity of humans and human interaction.
They are but they are trying to adapt. .NET core is an extremely aggressive way for them to attract the new generation.
It's funny because the new generations still use Windows to develop on and Linux to deploy to and no one is denying this. But Microsoft somehow is accepting this shift and is trying to bring its stack on Linux and also Linux on Windows.
I think Microsoft is smart,they really realized unlike Oracle and others that sometimes you cannot people force to use or do whatever you think is the best (looking at you Oracle,IBM,Apple) and literally giving people what they want is the best thing you can do to turn the tides.
Ehh, using Electron to write a relatively lightweight wrapper for Monaco (the editor component that was developed for an entirely different product) was an obvious technical choice if you were no longer restricted to only using Microsoft technologies. There's not a reasonable/supported alternative to Electron within Microsoft.
For all of Microsoft's attacks on open source, although not altruistically, their embrace of open source is not that recent. People seem to forget they launched a successful open source hub (CodePlex) two years before GitHub, which enjoyed popularity for years.
F#'s compiler and tools has been Apache licensed since, what, 2005?
CodePlex was created because they didn't want to use the (at the time) standard for Open Source, SourceForge. They abandoned it when GitHub rose to prominence. This was pretty much exactly what Google did as well, with Google Code.
On C# having had an incomplete ECMA specification always lagging behind and source code made available under an obscure, non-open-source, legally tainting license acting as a boobytrap for anything commercial DOES NOT count as open.
Even now they are being disingenuous about license changes, witness for example the leadership of this project changing license from Apache 2.0 to MIT and being obtuse about the licensing of patents or about reasoning, not explaining clearly the drawbacks of the change: https://github.com/Microsoft/visualfsharp/issues/3440
OpenJDK happened on May 8, 2007, that's 10 years ago and you've got companies like Red Hat and IBM collaborating on it. By comparison .NET Core was released 2016, so that's 9 years later.
And the JCP might be a farce as far as standardisation efforts are concerned, but at least you've got multiple companies participating.
I'm replying this because I'm getting tired of Microsoft's marketing campaigns on this forum.
UPDATE:
Btw I actually applaud Microsoft's open sourcing efforts, I see myself using .NET in the future and I'm actively using Visual Studio Code and TypeScript at the moment. They've got fine people there working on dev tools, they always had.
But then I also see them engaging in what's basically racketeering, threatening Android phone makers with patents (i.e. if you can't innovate, litigate), having potential for becoming one of the largest patent trolls ever. And I also see them breaking user privacy in Windows 10. Therefore my view of them is balanced, as a large organization the left hand doesn't know what the right does, etc.
I cannot love them and even though I may have forgiven them for their past attacks on Linux and the open web, I can't forget their past that easily. And before you mention Google, Apple, Facebook, or other media darlings, check my history to see that I'm consistently ranting about all of them and the malevolence of one does not excuse the rest.
What I'm saying is that "Microsoft changed" messages make me feel nausea because it's been a clear marketing campaign and people fell for it. Let their actions speak, applaud and reward them when they do good, but don't put them on a pedestal and don't do marketing for them without getting paid for it.
> OpenJDK happened on May 8, 2007, that's 10 years ago and you've got companies like Red Hat and IBM collaborating on it. By comparison .NET Core was released 2016, so that's 9 years later.
You're comparing unequal things. OpenJDK was a community effort, while .NET Core is maintained primarily by Microsoft themselves. The correct comparison would be to .NET's community based alternative, which is Mono. Mono in turn had it's initial release in June 30, 2004, which is _13 years ago_, and 3 years before OpenJDK itself.
Further, note that Oracle only open sourced Java a year after Microsoft did .NET Core. One might even argue that Oracle only did so _because_ of .NET Core.
I'll note that I'm replying because I'm getting tired of Oracle's marketing campaigns on this forum.
> You're comparing unequal things. OpenJDK was a community effort
> The correct comparison would be to .NET's community based alternative, which is Mono.
This is disingenuous at best. OpenJDK was started with a huge codebase from the existing Sun JDK at the time, similar to how .Net core was started with with a Microsoft codebase.
Meanwhile Mono had to be written from scratch and was a far cry from being somewhat compatible for years after it started (e.g. capable of running a Visual Studio compiled .NET GUI program)
> Further, note that Oracle only open sourced Java a year after Microsoft did .NET Core
I'm not sure what you mean by "open source Java" in this context. The Java Community Process was started in 1998, and as said OpenJDK started in 2007. Java EE being open sourced like now would be much more comparable to Microsoft releasing something like Windows Presentation Foundation as open source, as it's a oft-used part of .NET but not part of the language per se.
No, you're wrong. You can compare Mono to GNU Classpath (1998) and the like. But OpenJDK was backed by Sun. They started releasing the source code in 2007. So it's 10 years ago.
If you want to take mono into account as the first free .net implementation you should take GCJ into account as free Java implementation. GCJ was started in 1998....
"The correct comparison would be to .NET's community based alternative, which is Mono. Mono in turn had it's initial release in June 30, 2004, which is _13 years ago_, and 3 years before OpenJDK itself."
Mono is owned by Ximian, which is now a subsidiary of...Microsoft. This creates the rather odd situation where there are three implementations of .NET, but Microsoft controls all of them.
.NET is far beyond Java as a platform for building languages though, and it's been that way right from the start. Reified generics, value types, structs, unsigned integer type support, intermediate language actually optimized for compilation. It's pretty nice.
For some reason Java people have a near allergic reaction to it though.
Reified generics are more of a problem than a solution for language creators. .NET generics are too weak to be the base for languages with really powerful type systems like Scala or Haskell. Therefore implementing Scala on .NET required to use erasure and turned out to be more complex than in Java, which supports erasure "natively".
Yep, the CLR/VM is a much better target for languages and C# fixes a lot of Java's mistakes.
It's such a shame that Microsoft until recently kept it so tightly controlled and Windows only. If that hadn't been the case the ecosystem (libraries and languages) might have been a lot more up to par when compared to the JVM ecosystem.
It never was "Windows only": https://msdn.microsoft.com/en-us/library/cc749640.aspx. Mono arrived shortly thereafter. And it had open spec right from the start. Patents were an issue though, there's no disagreement on that point.
Mono was awesome for what it was, and I'm not trying to denigrate those early efforts, but what it was wasn't really enough to say .Net wasn't Windows only. It didn't support WinForms, so no GUI application built for Windows would work on Mono without a major rewrite. Performance was also pretty bad in my experience. We built an optimization engine while I was in grad school for a funding source that mandated Windows, so we wrote the application in C#/.Net. I would develop on Linux at the time, and I built a version of the application that had no GUI so it could run under Mono, but it was easily an order of magnitude slower.
It kind of worked for a small slice of .Net programs (e.g., those that didn't rely on WinForms or any other non-implemented part of the stack). That's about all you could say for it for quite some time.
Mono was great for the kind of programs you would write in Python if you worked for a company that used any F/OSS under protest and held it at arms length when it couldn't avoid using it.
Not sure how it is now, but the requirement to run Windows in order to be a first class citizen, as .NET required for most of its existence, is enough to give me an allergic reaction.
I was the same. I lived only UNIX/Linux and knew where things were. In retrospect I can't even look into the mirror now on how wrong I was.
Don't take me wrong I am not saying that Windows / MS stack is better. It's just as good! And that's the beauty of it. I am glad microsoft is embracing other platforms so lets see how other people will react :-)
Meanwhile .NET is only fully usable in Windows for many types of applications, because .NET Core and Mono don't support all the platforms that Java does and .NET Standard 2.0 does not yet cover APIs like WPF, Systems.Drawing, WCF, ADO.NET drivers for all relevant enterprise databases.
So it is not like everything is better on the other side.
Note that I do enjoy using both of them since their early versions.
Java had an open specification (if you mean freely available and accepting contributions), open implementations, and allowed open-source contributions, for years before C# did - I don't know what you're talking about.
This post is just about JavaEE - a set of libraries for Java - being moved to GitHub.
All of this used to be on a (very very slow horrible) repository site called "java.net". They moved everything to GitHub now. Similar to MS shutting down CodePlex and moving to GitHub.
> Java is super popular in the open source and academic communities
Don't forget the business community. To a first order approximation, most programmers who get paid to write code work in either C#/.NET or Java. Everything else is a relatively small minority of paid development work.
I run into this issue often enough that I've been tempted to write a userscript to translate the java.net links automatically... doesn't do anything about all the broken documentation links though :(