The Java ecosystem has been slowly dying for years, it's already the new Cobol at this stage.
I have the impression that a lot of the mindshare has switched to the Node and Javascript ecosystem, especially the frontend devs, via the Typescript / Angular path, which is a natural path to Java developers due to the comfort given by familiar concepts like static types, classes, etc.
When I used to do Java, I always found that Spring was a much better framework than Java EE, and have used it in most projects I've worked.
Oracle did not take a note from the Microsoft book and is really behaving that an evil corporate overlord.
It's clear at this stage that they bought Sun in order to slowly turn Java proprietary, and charge billions to the companies that are now fully Java-based for the next few decades.
I'm glad I saw the writing on the wall and switched, but the problem is that Java is still being taught a lot at schools, and school programs especially universities are hard to adapt and only change every 4-5 years or so.
Working in the JVM world I'm always surprised to hear that its dying, the JVM and Java moves faster forward than ever, Graal is about to go 1.0, a bunch of very interesting (very) low latency GCs are in the pipe (for example ZGC and Shenandoah) and lots of other interesting projects like Valhalla promise to keep the JVM relevant for the next 20 years. Oracle have made some moves to monetize on parts of its investment, but the situation is largely misrepresented.
Too little too late, and I highly doubt that (5-year-old) Valhalla will deliver even one of the promised features (value types) in the next 3 years. Remember that the original plan was to have all Valhalla features in Java 10.
Java/JVM was in the ideal position to dominate the software world for the whole 21th century 15 years ago. Instead they did an IE6 and stagnated for so long that their competitors became plain better.
I'd say Java/JVM is now where IE was in 2008. Still massive majority market share, but in decline because people are switching to competitors. LLVM and webassembly are eating JVM's cake, and a multitude of languages like Kotlin, C#, Go, Rust and even Javascript and Python are chipping away at Java's market share.
It's hard for me to take all the "Java is dying" threads seriously when they don't even seem to understand where Java plays. Webassembly? Really? That's a client-side tech, and 99.999% of Java devs ceded the browser battleground pre-9/11.
Java's bread and butter is EAI, ETL, and server-side business application development. Particularly with pieces requiring heavily distributed design. Node might pick away at some of the lowest-hanging fruit (e.g. JavaScript webdevs writing their own REST endpoints to fetch user settings from the database). But most of that crowd doesn't understand what the terms "EAI" or "ETL" even mean. Hell, most of that crowd has never had the experience of working for a company that turns a profit. The next major downturn will be interesting to watch...
And JavaScript is the only JVM-alternative to take seriously at all. Hype trains come and go for Rust, .NET Core, Go, etc. But they never really gain serious traction beyond a non-Java niche area, and/or devolve into endless arguments about generics or whatever.
I've seen zero actual encroachment into anything that earns me money for the past 10 years now, and at this point I'll probably be retired before I have to worry about it.
You're right that Java is entrenched in a lot of the enterprise space, but I think you're being quick to dismiss entrants that have gained steam in the last few years.
For example, Go is becoming the default in Kubernetes applications. It's eating tech companies that became large in the last few years like Lyft and Uber. It'll spread to other large tech companies like Amazon or IBM with ease. It will possibly get picked up by a significant number of universities for undergrad courses within a few years as well.
Seriously, people. K8s is a container orchestration system. Yes, it's written in Go, like Docker itself. DevOps tooling is a niche area where Go has been very successful. But k8s runs whatever you put into your Docker containers.
I've seen no indication of it changing which languages people choose to containerize (Node containers probably being way more common than Go ones). If anything, easy containerization negates one of Go's strongest selling points (i.e. standalone executables with no need for a runtime environment).
Exactly! In the enterprise world, there is a lot of Java and .NET code that isn’t going away for a while especially since K8s makes it easier to port to the cloud. In my enterprise, the only other language that comes close in usage numbers is Python, so I think a lot of enterprise folks will opt for that over Go.
As someone who works on Kubernetes in the enterprise I would agree - there’s lots of go, but it’s newer and organized around the teams who were early adopters. And even the early adopters have massive Java, .NET, and increasingly Node footprints.
However I think the rule of enterprise software is that it’s increasingly fragmented and diverse - that’s partially why Kubernetes and containers were so attractive because it allows operations to unify footprint on prem and have a path to cloud.
Nobody in an enterprise ever stopped using a piece of technology. It lives on forever (and public cloud just gives it new places to live).
Go is really not a language to recommend for enterprise business applications. It's a niche and will likely stay this way unless they add tons of features, which they have been reluctant to do. Because otherwise they'll end up with Java, or something very similar, is what you end up with.
> If anything, easy containerization negates one of Go's strongest selling points (i.e. standalone executables with no need for a runtime environment).
I don't know about that, I think that is still a strong selling point for Go, even in a containerized environment. Somewhere I saw a statistic that says over 90% of container images in the wild contain unpatched CVE vulnerabilities and (searching...) [1] here's an article that shows just how bad the problem is, according to this article in just the top 10 docker images, there are over 8000 known vulnerable paths.
The reason is probably not because those 10 products are simply nightmarish from a security perspective and expose the lions share of the vulnerabilities in their own code paths, it's because of unchecked dependencies. If someone took a tree shaker to those images and removed all of the unnecessary packages that aren't real dependencies, you see that number going down by probably about 30% if not more.
Even then, you're still seeing lots of potential issues caused by far-away dependencies that we do actually need, but don't really care about. There's something to be said for a development stack that is geared toward automatically pruning out packages you've included when the compiler can prove you're not even using them, and helping you reduce the scope and size of your external, far-away dependencies.
From an InfoSec perspective that's the biggest problem I see in containerized environments, (and true that just not using containers won't really make it much better) so correct me if I'm wrong, but I think that Go does all of that for us.
I'm working with customers now that are running Kubernetes to host Java applications and microservices. I'm not a huge fan of Java or the ecosystem, or the fact you can build a Kubernetes cluster using maven, but to claim its dying is outright absurd.
As a consultant, I see Java widespread. Every organization is either writing Java or running an application dependent on Java that is also mission/business critical. Most of my work happens on the backend, but we see lots of Java upstream with mobile apps, big data, ETL, etc...
Go is a good language for developing middleware and automation tools, but it's not, at any rate, a replacement for Object-Oriented languages. Java, C#, Python, Ruby etc are much more suited to business-oriented apps, data science and so on.
There are many uggly things on Go language that can be considered nice features for system programming. Even though, if you go too much on the low-level (such as for operating system, drivers or embedded devices) it's still a issue to use go instead of a more hardcore systems language such as C++ or C. It is, at most, a niche language today. And probably will stay this way unless it goes into a major redesign.
Better to talk about Rust or Kotlin, which are languages that have much more potential and can be a real threat to the dominant languages/platforms today. But right now, they are too unknown to be taken in consideration just as many other good languages that never came to be.
I've heard that attitude before. C++ developers working in finance around 2000. They were damn sure that no-one was going to switch to any other language because reasons.
I'm sure there's still a bunch of C++ devs working in finance, and making decent money, but I think the industry has moved on now.
HFT gigs I’ve looked at were all C++, some even Rust now - because they don’t want the risk of a long GC pause messing up a trade (which means Java, .NET, and Go are right-out).
Go uses tri-color mark-and-sweep gc that runs concurrently and its latency is extremely short compared to .net and java (probably still not short enough to be put in the critical path of hft order processor tho).
Edit: I'm also confident you can ensure Go’s gc doesn’t run when you don’t want it to so there’s that.
This may be true but conventional wisdom against using anything GC'ed for real-time applications (like HFT or aerospace stuff) is going to mean even if go's gc is good enough, using any gc'ed language for these apps is going to be extremely rare for years if not decades. Seems far more likely that rust will chisel away at that market than golang or any other gc'ed language.
For arbitrage that must happen really fast, FPGAs is the way to go, and for complex code that needs to be rewritten often and quickly, Java is probably a better fit than C++.
There are active ongoing efforts to push wasm beyond the web client. Which makes perfect sense, since it could, in theory, deliver JVM's "compile once, run everywhere", but with a lot more flexibility for the languages on top.
As far as Node.js being the only JVM alternatively to take seriously, I don't even know what to say. There are lots of enterprises with mature .NET (not Core) business apps, doing all that very stuff that you list - EAI, ETL etc.
And then there's the evil implication of this aging, entrenched ecosystem. Companies who wrote their Java development process documentation did so in the 90's, with guidance from IBM or a "big 3," and now treat EVERY project in the business as though it was the same scale and complexity as the mainframe projects they were trying to supplement. Which is why it takes 6 months for me (on the FAST TRACK!) to even get a development environment for a simple CRUD web app designed to replace a terrible Excel spreadsheet with 5 users -- so that I can submit my feature list and test plan to review boards -- so that I can START writing my application.
No wonder it takes the IT group 2 years to write an application I can have in production in 3 months! I don't need a reverse proxy! I don't need redundancy! I don't need an encrypted file store! It's a shared, specialized to-do list application! I don't need the overhead of a global financial application running on Sun E10K's!
Nothing personal, but there are a lot of us out here who can't WAIT for people who have based their careers on "enterprise" Java to get out of the way already, and retire. When computers were as powerful as smart watches, we NEEDED all that distributed processing and faffing about with off-line data. Now? Not so much.
"Hype trains" Rust, .NET, Go, etc.? Maybe you, too, think that Rails is too "new" and "unproven" to use for anything.
I'm one of those Node devs who've mostly worked for companies who have never made a profit, and I've recently been exploring Go, Java and C# (.NET Core) given I'm starting to work on more "serious" (or difficult) backends (distributed systems) and am hitting the limits of the language and ecosystem I know. Genuinely curious - why do you think I should give Java my attention over C# or Go?
The JVM, Java and Scala have a huge ecosystem with Hadoop, Spark, many databases, etcetera. Go to any company that does a lot of data-intensive processing, and chances are very likely it's powered by the JVM in at least some of the components.
LLVM has replaced JVM as a programming language target bytecode in the last 10 years (except Kotlin no new JVM language). JVM has lost web to JS 20-15 years ago, and Webassembly is now taking shape as proper web bytecode.
I do not know what will be the most dominant language + bytecode in 25 years, but I would bet $10000 that it isn't Java and JVM.
Java's never going to be on the bleeding-edge of trendiness (thank goodness). But there have been fewer JVM-targeting alternative languages over the past decade, because Java itself started leaning in a functional direction. It became "good enough" to negate the purpose for most of them.
At any rate, counting compile targets for hobbyist toy languages is barely one step beyond measuring GitHub stars.
> I do not know what will be the most dominant language + bytecode in 25 years
In 25 years, I'll be long gone and you can have it. By then, the industry will be pushing to automate most programming jobs out of existence altogether, and you can be the old guard arguing against that.
I 100% agree with you on Java. Some of these people who compare Java to Cobol have no idea. It’s hard for anyone to predict the future in tech but at this point Java is so widely used in the enterprise that it’s foolhardy to think that Java will disappear anytime soon.
To the credit of the Java community they keep the language relevant and refreshed.
I agree it’s always about 1-2 years behind other languages in terms of features but most enterprises don’t give a damn. Most enterprises just want to get work done. They don’t care about functional or OO.
In the last 3 years I have seen maybe 40% of developers use the latest features from java 8.
So while java might be slow to catch up that’s what it’s customers want.
Spring and Vert.x and similar Java frameworks will always keep Java relevant that it will be hard to ignore
> Some of these people who compare Java to Cobol have no idea....at this point Java is so widely used in the enterprise that it’s foolhardy to think that Java will disappear anytime soon.
Isn't that PART of the Java to Cobol comparison? Someone making that comparison wouldn't be saying that Java will disappear anytime soon.
COBOL is a valid comparison in terms of its space occupied and the verbosity the language is. The difference is cobol is really mainframe era and java is mini / unix era. Its client side except via phone is largely gone. But like cobol still in mainframe apps, so would be java. We do not see that gone as mini/unix not dying.
The windows server running java is an area I am not sure and not much encountered. But windows and Microsoft languages are the only competitor here.
Client-side is gone on most languages. While there's still native mobile apps (and some rare desktop apps), the only language available on the client-side for the web is javascript or languages that can be transpiled to javascript. Flash, cold fusion and other stuff are gone. It's not a "Java is dead" thing.
>LLVM has replaced JVM as a programming language target bytecode in the last 10 years (except Kotlin no new JVM language)
LLVM only emerged as a major target in the "last 10 years", so there's that.
And JVM already had so many major languages it didn't really have much space for others (Scala, Clojure, Groovy, and so on, including fully working clones of Ruby and Python).
Still, 4 major new languages: Scala, Clojure, Groovy, Kotlin -- all in the TIOBE top 50, from a single platform (which wasn't designed to be a language neutral target in the first place, it just happened because of it being too successful), plus the number one TIOBE index spot (Java), sounds like enough.
Kotlin can run on the JVM and, Kotlin-on-the-JVM needs Java to even bootstrap. Also it seems that most of the interest for Kotlin comes from the JVM community and this aspect of the language. That is certainly the case for Android programmers any how. Backend JVM application server programmers use it as well.
My main non-JVM use of Kotlin is that when I want to use some arcane aspect of Kotlin, which I may not be too familiar with, I might write and test a small toy function on the command line using it and then copying it over to a big Android Kotlin project, as opposed to trying to work out how to use the arcane feature in the middle of a big Android project.
To me two things about Kotlin stand out over all other Java alternatives: 1) fantastic IDE support and 2) it does not add too much rope to hang oneself with (see re: Scala).
> I highly doubt that (5-year-old) Valhalla will deliver even one of the promised features (value types) in the next 3 years.
I'll gladly take that bet. People said the same about lambdas.
> Java/JVM was in the ideal position to dominate the software world for the whole 21th century 15 years ago. Instead they did an IE6 and stagnated for so long that their competitors became plain better.
I don't see any competitor coming anywhere near Java on technical merits. Not only is there no stagnation, but true breakthroughs -- in GC, compilation and observability are being made in Java and almost nowhere else in the past few years. That's not to say that Java doesn't have some glaring deficiencies but they're being addressed.
Are they being addressed too slowly? Perhaps, but that's something we've heard about Java for a long time, and the perception has usually turned out wrong. I think this is because such complaints are made by HN readership that misunderstand the industry's priorities.
> LLVM and webassembly are eating JVM's cake, and a multitude of languages like Kotlin, C#, Go, Rust and even Javascript and Python are chipping away at Java's market share.
Java's short-lived complete domination was a fluke. Now its market share represents a more normal one for a technological leader.
LLVM and webassembly are eating the JVM's cake only on HN. Kotlin shares well over 90% of its code with Java, and is a part of the Java ecosystem. C# has always been a big competitor, and Rust is not really chipping much away from Java as it's optimized for different domains. Go certainly took a bite, but its rise has stalled. This leaves JS and Python. JS has truly been a remarkable success due to its ubiquity on the browser, and it has taken a big bite out of all languages. Python is the most interesting one in the bunch. It is nowhere near as technologically advanced as Java, but it has other important benefits that many companies now care about.
> Too little too late, and I highly doubt that (5-year-old) Valhalla will deliver even one of the promised features (value types) in the next 3 years
I never understood the purpose of Valhalla. They should just introduce a 128-bit scalar type and call it a day. Nobody actually cares about automagically storing value types in HashMap — all interested parties (HFT, computing) have already written dedicated collection libraries for working with primitives, and those libraries have little in common with object-based ones.
> LLVM and webassembly are eating JVM's cake
pffft, hahahaha, no they don't.
JVM and LLVM don't even share same market niche — one is a feature-complete runtime, another is a "make-your-own-language" build kit. Webassembly? What webassembly?
> Nobody actually cares about automagically storing value types in HashMap
I agree. When I look at the allocation profiles and heaps of our Java applications (which I assume to be fairly typical Java enterprise applications) boxed types do not show up. What really matters are Strings, both in the heap and the allocations.
Kotlin is a JVM language, sold as a better Java, and the JVM is really the thing that is the echo system gathers around, not necessarily the language Java.
Other interesting languages you have on the JVM is Scala (multi-paradigm), Clojure (Lisp), EtaLang (Haskell)
Java is already losing market share to JVM competitor languages.
JVM is in a stronger position than Java, but imagine a world were 15-10 years ago native compilation for JVM bytecode became available instead of 1 year ago. LLVM wouldn't have stood a chance.
Kotlin and Scala (I'm not too familiar with Clojure and others) are hedging their bets and making JS/Webassembly and LLVM versions.
LLVM would have been created even if free/open source, SubstrateVM style tech existed back then because LLVM was designed as a competitor to GCC for compiling C and C++. The JVM can run C/C++ code these days 'natively' (by JIT compiling LLVM bitcode using Sulong) but that's not what it was created to do.
Also bear in mind LLVM is not really a JVM competitor despite the name. LLVM is a toolkit for building compilers, primarily, C/C++ compilers. Other languages that targeted it have had to do a lot of work to change LLVM for that language. It's not actually a "VM" in the JVM or V8 sense, for instance, it doesn't provide a garbage collector and LLVM bitcode is neither platform neutral nor a stable format.
Do you mean with Excelsior JET? I tried to compile an application totaling 157MB in jars to native with it just now. After compiling for 2 hours it was still only 15% done. I had aggressive optimizations disabled.
For example, PTC, Aicas, Aonix (now also owned by PTC), IBM RealTime WebSphere, some variants of J9, Android since version 5 (although it isn't technically a JVM), RobotVM, Codename ONE, GluonVM, IBM i JVM (uses OS/400 TIMI), JRockit.
I know for a fact that in the case of Clojure (and I assume the reasoning is similar for Kotlin and Scala) that targeting other ecosystems has nothing to do with "hedging", and everything to do with reaching other platforms and mediums.
>Java is already losing market share to JVM competitor languages.
Really, any examples? And not Go and Rust (down 30+ places in the TIOBE index compared to Java, and as insignificant as to not even exist in the global job market).
And C++ is still around, and one of the top choices, despite 25 years of other languages chipping away at it.
Java is very mature, it doesn't need to evolve a whole lot - and most everything you need is there.
Oracle is definitely a risk to this, but I don't see TS/JS/Node taking over.
Kotlin is a strategic choice by Google due to Oracle woes, otherwise it would be a very rare language: consider that it really hasn't made a big roar outside of Android, i.e. it's not really anywhere on server side.
Java isn't going anywhere for a while yet.
There will need to be some kind of tectonic shift for this to happen.
If Google or AWS for example fully embrace some new thing, that might do it - but I don't see what the candidate is.
Kotlin for JVM has a lot of potential. It takes a lot of the pointless busywork out of Java (this is Go's problem), yet the median hiring candidate can probably handle it (this is Scala's problem) and you don't sacrifice decades of library coverage.
Kotlin is nice, but to me it's mostly just 'different', not necessarily an 'advantage'.
Without Android adoption (and G did this specifically because of Oracle issues) I don't think anyone would really be using it. Outside of Android, it's not a big thing.
I've gone Java to Kotlin and back again simply because the few advantages to Kotlin just aren't worth the phase shift. FYI almost every single code example in Android has Kotlin and Java the same length. It's not really any shorter or more concise in the end.
I wish Kotlin well, and it's a great example of how the JVM can be leveraged.
The JVM is probably Java's greatest foundational asset, which is why Graal has such potential, if Oracle doesn't screw it up ...
At any given time most developers will neither have much real choice when it
comes to technology nor have a longer term perspective. Hence most developers will stick to what they know and what organizational inertia seems the path of least resistance.
The comparison to COBOL is good for several reasons.
My first bit of production Java code was an applet that used cobra to talk with COBOL in the Java 1.0 days. When I'm bridging new languages to Java codebases, I always wonder if this is the 'new hotness' I'll be driving next.
Similar position. Corba overhead too high and we use a middleware to handle it. But the aim is to migrate away those we can from mainframe. And use java in lieu of cobol.
> Working in the JVM world I'm always surprised to hear that its dying
So how is this "JVM world" escaping the grip of Oracle? E.g. graalvm is directly Oracle's, or am I missing something? Specifically, what is preventing any of the Java-related things people use now (including those that you mention) to end like the OP is describing?
Asking as somebody outside of that world, but interested "how much it's worth considering" under the given circumstances (Oracle being Oracle, demanding a lot of money for everything Oracle's that some company could use, and owning a lot of that "world"). Where are the boundaries? What is safe and outside of reach of Oracle? E.g. what is safe for a small company to use?
GPL is not usable for any small company which doesn't want to publish its own sources.
What can be used only using BSD, MIT, Apache licenses? And what from the GPL-licensed products is safe to use to produce and sell own closed source products (e.g. where the exception to GPL exists for just linking the libraries or similar)?
Edit1: Long term dangers/costs of depending on the technologies that need commercial licenses like Oracle’s are also important.
Edit2: And additionally, just as an old example, once I’ve considered using Berkeley DB in the closed source product (before some of the current alternatives were available), and my interaction with Oracle proved that only a bigger corporation could fund that. For a library which was already open source, but owned by Oracle. It's not that I'm in the "I don't want to pay for anything" camp -- I'm simply having a perspective of a small player. And about small players Oracle couldn't care less. However, the significant changes very often come at that level of cheapness and overhead, most of technologies would be still not widely accepted otherwise.
There are different levels of what’s allowed for different GPL based licenses. To use a library as a library with another license a GPL library exception has to exist for the library etc. If you step on only one of such mines your whole product has to be GPL-ed.
It the context of my questions here, and as an example, my guess is that I can't use graalvm to produce a binary which I can sell without either open sourcing everything I've made or paying too much to Oracle. But I don't know for sure and for each of the mentioned technologies, that's why I'm asking very specific questions.
> my guess is that I can't use graalvm to produce a binary which I can sell without either open sourcing everything I've made or paying too much to Oracle.
GraalVM CE is licensed under GPL 2 with Classpath exception (https://github.com/oracle/graal/blob/master/LICENSE), specifically so that binaries created with GraalVM (which contain the GraalVM runtime) don't fall under the GPL.
> So how is this "JVM world" escaping the grip of Oracle?
Why would you? What is the point of "escaping"? It is like asking, "how would Go world escape the grip of Google?" — no one cares to, because nobody asks Oracle for permission to make software for JVM.
Java EE has been in maintenance mode for a long time, but Spring and Dropwizard are alive and well despite that. Incidentally, Nginx Unit has recently implemented Servlet spec — a cornerstone of JEE! — but they are stuck at it's initial version, without asynchronous Servlet support. Maybe Oracle should give Nginx a couple of decades to catch up before drafting next JEE version...
Oracle seems hell-bent on undoing the openness around Java that SUN was allowing. What I'm reading between the lines of this report from the Oracle-Eclipse negotiations is that Oracle wants to roll back the world to a "thou shall not have a JVM besides mine" state with a hefty price tag on commercial usage of their VM.
I'm sorry, but as bad as Oracle's sales and legal behavior has been, I don't see how the evidence supports your claims.
Oracle has open sourced (or deprecated and removed) the remaining commercial elements in the JDK -- OpenJDK now is truly the complete open reference implementation of the JDK, JRE, and JVM.
OpenJDK is an open distribution and preinstalled on all major operating systems and is now the standard JVM for most developers. We even have open distributions of it e.g. Amazon Coretto.
GraalVM isn't even at version 1.0 so nothing at all to worry about.
> OpenJDK is an open distribution and preinstalled on all major operating systems
My understanding is that it is preinstalled on chrome os and android, but is not preinstalled for any major linux distribution, is a separate third-party download for windows and Mac, and is unavailable for iOS.
Last time I used MacOS, it prompted me to install Java and then it did the install. I was in the Terminal, I am not sure what the interaction would look like if I had double-clicked a JAR file.
I believe Apple donated their customizations (Swing L&F, launcher code, etc.) to OpenJDK.
This is Apple's old build of Java 6, and is currently downloaded as needed for backward compatibility. Anything newer than that the third party is expected to bundle into their application.
Java the language is slightly different than JVM but nevertheless the future is not very bright IMO. So far there are a few areas Java/JVM still holds a strong position but if you take a look at GitHub trending there is little or now new blood coming in.
- Android. No serious competitor to Java yet (JVM is irrelevant). But the Google lawsuit could have some complication.
- Spring stuff. I won't be surprised if they will be replaced by golang and nodejs (along with react/angular/vue etc). Same path for RoR.
- Data processing: Spark stuff, PrestoDB, Flink, Kafka, Hive, HBase, Lucene/Elastic etc. Java/JVM is still dominant but golang could be a future contender. A few new application databases/KV stores are implemented in golang.
The problem for Java is that the last category is mostly services (instead of libraries/frameworks) so you can potentially use any language to work with them, and the industry probably won't create many jobs for building generic services especially in the cloud era. So having the dominance doesn't provide a lot of protection.
Golang, at least in its current incarnation, has no chance of replacing Java in its core use case - business processing. Golang is replacing infrastructure that used to be written in C, which makes sense considering that's what it was designed for.
It's weird that you put Spring and react/angular/vue in the same sentence, because there is no overlap in these problem domains.
Just take a look around to check out new enterprise MIS projects being implemented with a simple golang backend + reactjs etc frontend. The adoption of intereactive/responsive and single page web UI, and the more iterative development practices are certainly driving to a different direction compared to Spring (and RoR etc). I think the main force is from the frontend tech here and that is why you see them in the same sentence.
Perhaps Golang was designed to replace C, but from what I've seen that doesn't seem to be happening. Most converts seems to come from the other direction, from Python and server side Javascript.
There is a clear trend there to grow static features, and I think a lot of people ask themselves why they shouldn't go directly to a more traditionally compiled language then.
Spring is really nice, but all the flexibility comes at a cost. Annotation meta-programming, runtime reflection, constructing proxies, classpath scanning... all contribute to a perception of slow JVM startup times that makes something like Spring Boot unsuitable for really small services or utilities.
I know there are other Java frameworks out there that are more optimized for smaller modular projects, but there's also the cost of operationalizing the JVM in something like Docker. Fat JAR deployments are relatively simple, but tuning the JVM isn't always straightforward. I'm definitely jealous of the simplicity of producing a single binary as your deployment artifact.
I can see you're a Go fan but I think .NETcore has potential to start eating away at Java in a big way if Microsoft continues on its current path. They can actually provide the enterprise level support big corps want.
.NET's developer community is in no place comparable Golang's or Javascript's. Just take a look at GitHub's trending page by programming languages. Javascript is really bad for server side applications, and yet here we are with so many nodejs server apps. It doesn't matter much how good a tech is. What matters more is what the new generation is using, which you can get a sense from the trending page on GitHub.
I've hated Java for years, but recently I think it has become usable again. I've looked at GoLang and Node, but I've kind of given up on them, too. GoLang I would consider for specific use cases. NodeJS just seems to insecure and "wild".
Was hoping that Kotlin+Spring could be a good alternative to GoLang for realtime apps, but haven't tried it yet.
> The Java ecosystem has been slowly dying for years, it's already the new Cobol at this stage.
This has been said for at least the last ten years. Not only is Java not dying, but companies like Apple and Facebook (not to mention Netflix, Amazon and Google, that are mostly or largely Java already) are increasing their investment in the platform. This was not the case when COBOL was 25.
The reason this is so is that Java is by far the most technologically advanced server-side platform in existence. It continuously presents technological breakthroughs in GC, compilation, and low-overhead profiling technology (just in the past few years it did so again in all three -- with ZGC, Graal and JFR). Node, Python, Go, Erlang -- none of them even come close. .NET comes closest, but even it is pretty far behind. This certainly wasn't the case when COBOL was 25.
It is true that for a short period of time, somewhere between 2002 and 2005, Java was more dominant than it is today, but that was a fluke. More "scripty" runtimes and languages were usually more successful in the "smallish software" domain. In 1995-2002 that was VB (and others); now it's Python. Also, there has been some decline in all languages due to the ubiquity of JavaScript on the browser, but Java did not suffer more than others. Maybe less so.
> Oracle did not take a note from the Microsoft book and is really behaving that an evil corporate overlord.
Oracle has just open sourced the entire JDK. Sun didn't do that and even .NET isn't entirely open source. I have no knowledge or involvement with EE, but it seems Oracle simply doesn't have faith in EE, and doesn't want the Java trademark associated with it.
(I work at Oracle on the JDK -- i.e. OpenJDK -- but speak only for myself)
I think you’ve drunk the kool-aid a little. Outside of complex projects headed by PhD compsci students (who used to learn java in uni but those courses are now taught in python) there isn’t a whole lot of mindshare going towards java these days. At least in regards to new FOSS projects.
I can say that my company’s use of java is diminishing rapidly over the last 5 years too.
No matter what you think of the technological advancement of the language and ecosystem- it matters not if people are not using it.
Oracle itself is a pariah, the vast majority of the tech industry avoid it.
> there isn’t a whole lot of mindshare going towards java these days. At least in regards to new FOSS projects.
No surprise, Java never had a great standing in FOSS. Most FOSS in java originates from companys or research-projects. Which might be the reason why many data science FOSS-tools these days are written in java. Sometimes I even get the impression apache foundation is now an oracle-sweatshop because of all the java-software they have now.
> No surprise, Java never had a great standing in FOSS. Most FOSS in java originates from companiess or research-projects.
Huh? You have Spring and Tomcat and Jetty and Spark and Netty and Kafka and Lucene and ElasticSearch, and even the Java language alone is consistently in the top three most popular languages on GitHub
Don't know about kool-aid, but if you want to do interesting platform work -- on GC, compilers or low-overhead observability -- you could work at Microsoft on .NET, at Google on V8 (or Go), or at Mozilla on WebAssembly, but the truly cutting-edge, state-of-the-art work is done at Oracle on the JDK (and related projects like Graal), which is where I get to lead a project to add delimited continuations and fibers to the JDK. We're obviously keeping an eye on what's going on elsewhere, and while there are certainly great ideas out there (some we're happy to steal, as others steal from us) we look around and don't see similar overall technological leadership elsewhere. That's not to say others won't pick up mindshare or win certain niches, or that technological leadership is the determining factor, but if you're in interested in the technology and familiar with what people are doing, it's hard to deny that Java is ahead of the pack in the technologies I mentioned.
> there isn’t a whole lot of mindshare going towards java these days. At least in regards to new FOSS projects.
I'm not sure your numbers are correct. Java is not the only game in town as it was for a few years in the first half of the naughts, but "not a whole lot of mindshare" seems to be detached from reality. I can't predict the future, but remember when PHP had all the mindshare and totally killed Java? Remember when Ruby did the same? I would like to think that Java still being the leading server-side platform after being killed over and over has something to do with its technical excellence, but I know that's being naive. Nevertheless, wishful thinking on the part of some don't make reality, and usual fluctuations don't make a trend. Eventually, something will kill Java -- or at least mark its true lasting decline -- but it doesn't seem like that something is here yet.
> I can say that my company’s use of java is diminishing rapidly over the last 5 years too.
That may well be, but we're also seeing companies switching to the Java platform in quite significant numbers, in cases where both performance and observability are top priorities. There seems to be movement inside the Java ecosystem (e.g. among the Java language, Kotlin, Clojure and Scala) or outside it (e.g. people switching among Ruby, Python, Node and Go), but we're not seeing any significant shift away (except on the client side, where the browser has won). There are also certain niches, like machine learning, where the Java platform isn't number one, but it's doing much better than Node, Go or .NET.
> Oracle itself is a pariah, the vast majority of the tech industry avoid it.
I'm not a manager, but I'm not sure the numbers support your conclusion. The opinions developers voice on HN and Reddit are... fickle, and don't necessarily reflect market shifts. In any event, the competition doesn't seem to be doing too hot in comparison, either. I can tell you that personally I'm certainly unhappy with some of the things Oracle has done, but at least it's not surveilling on the entire world, putting thousands of small businesses out of business, or getting kids into conspiracy theories. Also, my colleagues are so far not famous for outbursts of racism or misogyny. Now, I admit that’s not exactly high praise, but these days, as far as Big Tech is concerned, that’s not not nothing, either, and I’ll take annoying some other corporations over those any day.
Here is my fickle opinion of course not reflecting of market shifts.
A couple of years ago I was a CTO of a midsized company which had a misfortune of building the main product on top of Oracle DB (decision was made before me).
Oracle the database is great: performant, scalable. A bit pricey and complex to manage but that's acceptable for what it delivers.
Oracle the company is absolutely horrible. I've never dealt with anyone worse than Oracle.
Just one example: we accidentally turned on a feature called "advanced data guard" or some such. The DB is large and complex, it was a mistake of one of our DBAs who reported it right away. We never used the feature and could prove it with logs. Nevertheless Oracle demanded us to pay close to $1m or they would shut us down: we would have to discontinue the use of the entire DB in 30 days which was impossible.
The funny thing is that once ADG is turned on it cannot be turned off. Which made me suspect that such traps were created on purpose.
We ended up paying less than $1m but in the form of purchasing their cloud services. Apparently that's how their sales people get commissions.
But, dear Oracle, I've learned my lesson. Never again will I use anything with Oracle name on it. No company under my leadership will use anything Oracle. Not even Java or MySQL. Regardless of the technical merits of the product. Oracle is too underhanded to be trusted.
P.S. We also decided against using the Oracle cloud services we paid for. We just let it sit there, never even logged in. I'm sure Oracle reported their cloud as growing.
"Never again will I use anything with Oracle name on it. No company under my leadership will use anything Oracle. Not even Java or MySQL. Regardless of the technical merits of the product."
Now THAT is leadership I can follow. So, uh... you hiring?
I don't know about these things, but I totally believe you. There are much worse things than not forgiving a customer's mistake Oracle does that I do know about and very unhappy with, but the sad reality is that even with all that, it's still much better than Google, Facebook, Amazon, that are even more underhanded and even less trusted (perhaps not necessarily because some manager at Oracle is trying not to be as horrible as them, but because they would be as bad if they could but can't).
This is the most relevant comment for this article.
I know a lot of companies who got bitten by license changes from Oracle like „You run one DB on your VMWare environment? Now you need to lic every cpu in this cluster although you just use one. Or you drop VMWare and use Oracle virtualization products, then you just have to pay for that one cpu“
My bet: Java lic not allowing you to use PostGres
Last time I had to download a JDK I got a warning about having to pay a license for commercial use. I think most enterprises care more about the licensing arrangement than access to the source.
The licensing arrangement is that the JDK is now completely free (rather than mixed free/paid as before). Oracle offers the same JDK under two different license -- one, commercial, for those who wish to buy support, and one free. That page you went to described the two options, and referred you to the free one: http://jdk.java.net/
The "free one" that Oracle refer people to doesn't even come with a Windows installer, nor does it have any useful installation instructions. It's (presumably) intentionally unusable to all but the most persistent and technically knowledgeable users.
First of all, the JDK doesn't need an installer. You can put the JDK wherever you like and just point JAVA_HOME to it. Second, the JDK is intended only for developers. We have discontinued the "consumer/desktop JRE", and it is now the recommended practice for developers to create their own embedded runtimes with jlink. We are also working on a tool that would allow developers to package their applications with native OS installers [1]. Third, nearly all OpenJDK contributors are Oracle developers and use those builds, and AFAIK few if any OpenJDK contributors use any other build than the Oracle or the Red Hat ones, and so if you want anyone to fix your bug, you need to report it against an "official" build. Fourth, I don't know why you put free in scare quotes. It is the most popular OpenJDK distribution and it is as free as all the others (because all OpenJDK distributions are released under the same OpenJDK license; they are all owned by Oracle, BTW). Finally, you should ask yourself why is the OpenJ9 JDK, which makes up for maybe 1% of their downloads, featured so prominently on Adopt? Well, the reason is that IBM is in the habit of finding promising community projects, throwing some money and people at them, and taking control. This is what happened with Harmony, what happened with Adopt, and my guess is -- though I have no knowledge of the situation -- that this is precisely what Oracle feared would happen with Jakarta. This may not be bad if IBM also contributed something to OpenJDK, but they don't [2]. They just take over community projects, and then take credit for work that's done by Oracle. IBM taking control over Adopt is also why they lost their TCK license. The TCK is licensed freely for OpenJDK builds but requires payment for non-OpenJDK builds. IBM used Adopt to run the TCK on the OpenJ9 JDK -- not an OpenJDK build -- which put the entire project in violation of the TCK terms. So this entire story should be viewed in this light, as well: we have a company doing nearly all the work an an open source project and other companies wishing to exploit that.
You need to realize that Oracle does over 90% of the work on OpenJDK, and that the Java ecosystem is so big that there are other very large corporations who want to make money off of Java, and so are very interested in painting a picture of a "non-cooperating" Oracle. But again, whether you use a build from Amazon or Adopt, those source code behind those builds is developed and maintained by Oracle developers. And I can also tell you that we beg companies that build distributions or make money off of Java to contribute more, but so far, they can't or won't. We're happy to see Google starting to contribute more, and, of course, we've been cooperating with Red Hat for a long time. But so far, Amazon and IBM contribute little if at all (but I will say again that some companies cooperate nicely with Oracle -- Red Hat, SAP, and now it seems like Google may be starting to do that as well).
>it is now the recommended practice for developers to create their own embedded runtimes with the JDK tooling
I am unfamiliar with Java and am curious: if I open 2 Java-based apps on my Mac or Windows box, how much of the memory devoted to Java tooling that would have been shared if the apps were built with the assumption that there is a JRE already installed locally is instead duplicated because of the recommended practice that you describe?
Very, very little. Applications don't include the whole JDK, but a custom runtime they create with a tool called jlink (I meant that JDK tools, i.e. jlink, are used to create the custom runtime, not that the runtime includes the JDK tools). That runtime is only a few tens of megabytes (smaller than the shared JRE, as only modules actually used by the application are included). Also, the decision to do away with the shared JRE was sort of forced by shifting consumer and OS behaviors, that no longer encourage shared runtimes, but are shifting to containers and app stores. So whether a shared runtime is technically a better approach or not is moot, because the entire software ecosystem is shifting away from them.
This seems to be the correct answer - it appears to be the only way of getting a properly working install of OpenJDK for Windows that will actually be found by other apps - but it's a third-party build of OpenJDK backed by most of the major Java supporters except Oracle.
It is not backed by Oracle because OpenJDK's developers, who are 90% Oracle employees, do not use this build and don't know how it's made (it doesn't just use the OpenJDK make files), but rather the "official" OpenJDK build at http://jdk.java.net/. Similarly, the "official" OpenJDK build for 8 and 11 is the Red Hat one here (hosted on Adopt, but not an Adopt build): https://adoptopenjdk.net/upstream
These are the only builds for which you can directly report OpenJDK bugs against. This is not because of some conspiracy, but merely because most organizations that provide JDK builds (like Amazon or Adopt) do not contribute much or at all to OpenJDK -- usually because they don't have the resources or the knowledge, and in some cases because they don't want to.
Because the responsibility of developing and maintaining OpenJDK -- in all builds -- mostly falls to Oracle developers, we can only "back" builds we actually know. If you find a bug in Adopt, you'll need to report it to someone who will first reproduce it on an official build and only then report it to OpenJDK, where, in all likelihood, an Oracle developer will address it. Other companies can back Adopt because they're not the ones who maintain the project, anyway, so they bear little or no responsibility. We're happy that OpenJDK is doing so well, but with limited resources, we can only focus on builds that are under our control.
JavaScript is practically stone age compared to Java. Debugging is a nightmare. Documentation is a nightmare. Scaling is a nightmare. NPM is a thousand monkeys at a thousand typewriters.
Java suffers from having some 20-year old codebases because it's been so popular for so long but I can open up a 2004 WebLogic project in Eclipse or InteeliJ and trace everything it's doing. And modern Java has added all the nice features we expect a modern language to have. Java's slow demise is due to terrible PR and Oracle's endless insistence on JEE when every sane developer is using Spring.
I am not very sensitive to all those issues, I find the JS/CSS/HTML web stack a bit antiquated (virtual DOM, LOL), but very usable.
But the build toolstack is a pure, unadulterated nightmare. I used to think Maven's XML orgies, archetypes and learning curve were bad, but diving into Webpack et al was a new dimension of horror. This time based on JSON, though.
Time for another sortie by the COBOL evangelism task force.
Java has been the new COBOL since its inception in the 1990s.
I programmed quite a bit in COBOL early in my career. It's an extremely efficient language for scanning records especially in an era when a large proportion of data was stored offline on mag tape. Most common business problems of the era could be expressed and solved effectively in COBOL, which is why it became so popular.
I programmed in both C++ and Smalltalk in the early 1990s, which were innovative but also difficult to use for large systems. Java hit a happy medium with its C++-like object syntax, built-in libraries, and virtual machine operation with garbage collection. Add in the network effects from wide adoption (leading to tools and libraries) and it became a huge hit.
Oracle seems to be going out of its way to submerge the language in confusion. But nobody should mistake this as a reflection on the inherent capabilities of Java or its fitness for use.
I think you're missing the point of the COBOL comparison. It is not meant to imply that Java is similar to COBOL as languages go, or that it is as bad as COBOL, or even that COBOL is bad.
In fact, you described exactly why it is the new COBOL: because it is also an efficient and popular language for common business problems of our era, that is hugely popular, but mostly in "unexciting" places like large internal enterprise apps, out of sight for many. And just like COBOL, it will keep ticking on like that, probably forever.
Spring is compliant with and reliant on many of the JavaEE specifications - JDBC, Servlet, JAX-RS, etc. It provides DI that is not JavaEEs CDI.
I'd consider Spring as more of a non-JavaEE application server. Pick either Spring or Wildfly/Glassfish/Websphere/etc and you're either using part of the JavaEE specification with the former or the full specification with the latter.
Avoiding JavaEE for micro-services requires moving to something like DropWizard. Instead of a 200MB application server you end up with a 20MB application. Unfortunately, running that application in a Docker container will spin up a 180MB JVM. So the main reason we're moving away from JavaEE is actually more related to our move to container orchestration and that was originally driven by our adoption of micro-services. If you write a micro-service with a single end-point why should it use 500MB of memory?
Java is much closer to C++ than COBOL. COBOL has been massively obsolete for decades. Java has a lot of historical cruft but the basic syntax is still somewhat modern, mostly based off of C++ and agruable better.
Like C++, it's modern features are being slowly added. There's a huge difference between Java 8 and 11, in performance and features. Innovation is hardly dead.
Java EE and Spring are both terrible. I recommend trying some of the newer frameworks out there to see how much nicer things have become. DropWizard is my favorite right now.
I'm no Oracle fan, but Java is more "open" in many ways than it has been since the beginning. It wasn't till a few years ago we had a feature-complete high performance OSS implementation as the standard.
Oracle will try to ruin it, but the GPL JDK and history of projects being forked away from them makes it fairly safe. It's not in the interest of any Java user to have more than one standard.
IMO Java isn't going anywhere. It's been top 3 most popular language for over a decade. JS is somewhat promising but will never match Java in performance and multi-threading support due to core design decisions. Go is too verbose to get industry buyin to replace Java in most use cases. WASM is promising in the far future but it will take years to have a full browser and server ABI. The only real contenter to replace Java is C# and so far it's not getting much traction.
If anything killed Java it would be C#. Value types, no type Erasure, unsafe code and some native vector support. But it hasn't and probably won't ever dethrone Java. Java has a combination of decent features and an insanely huge amount of library support that makes it the default language of many companies.
How can a languages and its ecosystem that is being used actively in many projects within ALL Fortune Global 500 company and most Fortune Global 2000 be dying?
When people say Ruby is dying, it would be more accurate to say they are not growing or they are shrinking. But given the size of Ruby marketshare of less than say ~2%. I would not really disagree with their notion.
But Java? I mean even from a Web Development prospective, given you mention Node, JS and Spring Framework, it is Far from dead.
And this is speaking as someone who likes Ruby and dislike Java.
Recently started working on Typescript project and it looks to me like java with really poor tooling, C++ like compilation times and huge mess in libraries (i.e. how to determine which version of @types package I need). I think that Typescript is really step back from java.
As a Delphi developer this is the first time I heard about Java is dying, and in a reply the other one said that some is saying so for over a decade :D
And I think Java is more alive then Delphi, at least no one is setting up a site like http://www.isdelphidead.com/ :D
On the contrary! They are likely very aware of Microsoft's strategy and probably regard it as being too soft. They intend to milk their technology to the last drop.
You and I may regard it as evil, but it's a perfectly valid strategy. Perhaps it's more common outside IT? It's the brutally honest business strategy.
I can sort of appreciate that they don't play around. Perhaps not my first choice of technology, but you certainly know where you have them.
I've spend quite a bit of time doing javascript and typescript lately. Typescript definitely patches up a lot of the ugliness of javascript but you still deal with the same messy ecosystem of tools, libraries, and other cruft. It's been slowly getting better over the years but it's still not that great. I see typescript more as a gateway drug for people who seem to think that Javascript is all there is and then discover that actually having a type system unlocks all these amazing new tools that the rest of our industry has been enjoying for a few decades.
Guess what, if you like typescript, you'll love Kotlin. It's a much cleaner language, just as expressive, and it has a whole range of things that typescript simply can't do or that it simply does better/more elegantly because typescript is stuck preserving compatibility with javascript and all it's weirdness. MS has done a wonderful job of shoving a lot of that under the carpet with typescript but fundamentally types are optional because all javascript has to be valid typescript and therefore it has to also allow all the silly hacks, misguided features, and other cruft that javascript people have been coming up with for the past decades.
You might also like C#, Rust, Elixir, and several other languages that each offer their own tools, libraries, and features. I'm seeing a pattern with many frontend developers in the last few years that they at some point become full stack developers and shortly after start adding more languages to their repertoire. I know former node.js developers doing Rust, Go, Elixir, Kotlin, Rust, etc. now. Most of them are not very eager to move back to doing node.js projects.
Like Kotlin all these languages are all coming to the node.js/browser ecosystem through WASM. Full stack in 2020 is going to be a very different beast than just a few years ago.
Right now WASM already allows lots of languages to be used for just about anything that people currently do with javascript and typescript in browsers or in the node.js ecosystem. As this becomes more mature, people are inevitably going to change the ecosystem. This is already happening. E.g. Rust is being used for many low level npms for a few years now. However people have also been developing frameworks and libraries in Rust that work around/replace that ecosystem entirely. For a Rust person dealing with crates is preferable to dealing with npms, webpack and all the other stuff that is used in that ecosystem. So, they are fixing that. The goal there is to run pure rust in wasm in the browser or on v8 with 0 npms pulled in or used during the build process.
Likewise, there's an ecoysystem of multi platform kotlin libraries emerging and that allows you to build wasm or native applications and libraries without needing things like webpack, npm, etc (but using gradle instead). Same with C# and blazor. Each of those ecosystems uses browsers and node.js as runtimes but try to minimize/eliminate/replace most of the rest of that ecosystem. In the same way the Kotlin ecosystem is also starting to provide alternatives to stuff from the java EE and Spring ecosystem. E.g. Ktor is a multi platform web application framework that you can use instead of spring boot and run natively or on the jvm. It's also a drop in replacement for anything you might want to do with e.g. express.js. Doing express.js applications in Kotlin is of course also possible, but why would you when you can have ktor instead? In the same way building react applications in Rust is possible, but replacing it with a rust specific framework is much less awkward.
So, I agree things are changing but I'd say the node.js/browser landsace is changing as well and will not involve a whole lot of javascript/typescript for people coming from the JVM or other ecosystems.
You might make the point that there are all these millions of npms out there that can't be replaced easily. I'd counter that with the point that an awful lot of them seem to have very short shelf lives and are in fact replaced/discarded regularly.
I would not go as far to say it's dying but it's heavily slowing down for sure. First because of the big move out of the "entreprise" software and secondly because of Oracle legal team. It's definitely due to the licensing that Android is switching to Kotlin for example.
a) Java/JVM hasn't moved out of the enterprise space at all. Not sure where you got that idea.
b) Android isn't switching to Kotlin because of licensing since it is a JVM language after all. It's purely because it is a much better language than Java and has great tooling courtesy of Jetbrains.
> a) Java/JVM hasn't moved out of the enterprise space at all. Not sure where you got that idea.
It's the opposite, it's that old school entreprise type software & frameworks are getting less used.
> b) Android isn't switching to Kotlin because of licensing since it is a JVM language after all. It's purely because it is a much better language than Java and has great tooling courtesy of Jetbrains.
I think it's a mix of both, getting sued by Oracle probably did not help.
Compiler speed is a fantastic tradeoff. I'm made of meat that runs at maybe 0.0001 MHz after coffee, so I want to offload anything I can to the compiler!
All of these are technical issues which will be solved by Google eventually, I'm not worrying much about that, they definitely have the resources to make it work.
And there is Kotlin-Native but the likelihood of JetBrains reimplementing the entire JVM SDK is pretty slim. Not to mention all of the common third party libraries e.g. Guava, HTTPClient.
Android and Linux apps support is made via containers, aka they are not native to the OS, and isn't supported across all Chromebooks models being sold.
That is not Enterprise Software. It is less the language and the frameworks which are making it Enterprise but the requirements placed on them and the software development lifecycles.
Imagine you do a medical product and the regulations needed for FDA approval require you to check for vulnerabilities in your product and build infrastructure. Have you ever checked all packages in a npm dependency tree for vulnerabilities?
> Imagine you do a medical product and the regulations needed for FDA approval require you to check for vulnerabilities in your product and build infrastructure. Have you ever checked all packages in a npm dependency tree for vulnerabilities?
The same way as any other language? With audits? I don't get your comment.
To write the same functionality I need 10x the packages (from 9x vendors) in JavaScript compared to a Java/.NET ecosystems. The infamous left-pad packages is a sample for something found in the base class libraries of the other languages. And this does not only stand true for vulnerability analysis but also for other analyze jobs like for licenses or gdpr compliance. The amount of work is just higher with the amount of packages you use.
I think the net amount of code ends up being pretty much the same, it's just spread over several repositories/sources/owners. That does mean it's more difficult without tooling to trawl through, but it's not like it's an order of magnitude or anything.
The interesting part is how professional the packages are handled. For example in JavaScript there a thousand of authors with very different understanding of their "responsibility". Some do not even provide a license (do not even care to put a "WTFPL" or "Unlicense" on it) and do not read bugs. Others, have a emergency response team and publish CVE records. The less packages I have, the better I can select them and monitor them.
Java/.NET/Python ecosystems tend to be more professional with this regards. JavaScript catches up but is not completely there yet (you can see this with the amount of repositories who add licenses in 2016/2017 timeframe, years after creation).
Hence, same amount of code, much more work (it is a magnitude).
Oracle makes Java a risk factor in all projects. I stopped approving new Java projects in my team 2 years ago after we switched to Go. This wasn’t a decision we took lightly and it took almost a decade for me to be comfortable with leaving Java behind.
But it is the right thing to do. Oracle is not trustworthy.
Strange attitude to take when you can just target OpenJDK and then it is completely irrelevant what Oracle does or does not do.
The fact is that every single one of the largest companies has some Java or Scala code within their core platform. And none of them have ever raised Oracle as a risk.
In this case we have Oracle using the JEE namespace discussion as leverage to try to force the Eclipse Foundation to distribute their VM with their products.
If Oracle had succeeded, would that mean that every developer that downloaded the Eclipse IDE would be subject to Oracle's licensing and a possible audit target? I believe that it would.
The most valuable corporation in the world as of this date uses zero Java for anything “core”.
Anecdotally, nearly every CIO/CTO I’ve encountered in the last few sees Oracle as a huge risk. Most particularly with regards to databases, which are even sticker than applications which have shorter life cycles.
Very few developers have access to the decision making process (or risk management imperatives)of executives of large organizations (and vice versa). When big numbers are involved the actual story and what gets told to the public are often entirely different things. This is why the “but we have OpenJDK” argument is practically a non-sequitur, yet seems a valid argument to many.
Oracle is, as you say, on the radar primarily because of databases. But it is really the risk of dealing with a company that is likely to screw you if they can do so with sufficient ROI (where the investment is audits and litigation)
Developers and CxOs/company boards risk very different things and when things go bad, have very different downsides.
I'm guessing the use of "as of this date" means that the parent comment is referring to Microsoft and not Apple, as at the moment by market cap, Microsoft is more valuable than apple by about $13billion
Ironically, .NET was created because MS tried and failed to take over the Java ecosystem using an Embrace, Extend, Extinguish approach that ran afoul of SUN's licencing deal with them.
That’s kind of the point. No job is secure that’s why it’s not a great idea for someone not to keep their skills current with the market and keep their heads down. It’s not hard to project that Windows only development is a dead end when even Microsoft is outright saying that all of its energy is going toward .Net Core and they have been moving toward cross platform development for the last half decade.
Even with being a reformed former team lead, Devops and plenty of AWS infrastructure and development experience and looking for a change to add on Docker and k8s, It still crazy not to have the table stakes of knowing the latest tech.
You're either disingenuous or ignorant of the history of programming languages. MS doesn't use Java because it's a direct competitor to MS's eco systems. Windows isn't required; enterprise software; taking away developer's mindset. Not a decision based on technical merit.
MS did have a Java clone 20 years ago, but gave up due to legal threat from Sun and the DOJ lawsuit.
Ironically, MS has quite a few of Android apps [0]. Has been for several years. I guess there is at least some Java there. Unless you don't consider Office "core".
It's likely that OpenJDK developers would be snapped up by other enterprise vendors. There's a serious market in the JDK now, which didn't exist before Oracle created it. Part of competing in that market is having upstream credibility.
What's the relationship between OpenJDK and Oracle, exactly?
As somebody who's not deep in the Java ecosystem, the precise relationship is not clear to me, but it does seem that Oracle is a major contributor to OpenJDK at least, most likely also involved with the project steering.
AFAIK, Oracle's own JDK is being built from OpenJDK source and they work on OpenJDK source directly. The only difference is that there is no official LTS of OpenJDK by Oracle. You have to either keep upgrading to newer OpenJDK (with potential breaking changes) or pay Oracle license to use their LTS JDK
> You have to either keep upgrading to newer OpenJDK (with potential breaking changes) or pay Oracle license to use their LTS JDK
I don’t think this is accurate. Alpine and Debian OpenJDK have been getting point releases (u###) through the distribution package manager. I’ve got apps running on openjdk 8 and 11 (the LTS versions) and they are still getting u### releases with security fixes and bug fixes despite Java trunk already having moved past 11.
It's sane to be leery about entering into any kind of contract with a counterparty as grasping and merciless as Oracle has proven to be. If they find an exploit in the GPL, Java projects are in for a bad time.
Just curious, what makes you think Google trustworthy (in relation to Go)? It is not surprising that corporates control and drive the languages and ecosystems in their own favor. IMO, Rust and D are truly open source, even though D lacks the corporate sponsor like any other major language.
« Oracle already started a blocking politics at the Eclipse Foundation’s board, where Oracle has a seat, and where unanimous decisions are needed. Oracle now has the power, and apparently will use that power, to block the foundation’s future. It demonstrated that power already in a board meeting, where they had the sole vote against an otherwise unaimous move. »
I hope other organisations with a director from Oracle are taking note.
For me it's more a lesson about how unanimous votes, or unanimous - N can become problematic.
In the EU the same is happening. Poland and Hungary have found a loophole allowing them to ignore EU rules and sanctions while still profiting from subsidies and market access.
All sanctions against a member state require unanimous-1 (all states except the sanctioned member) votes and Poland is vetoing all sanctions against Hungary, and Hungary all sanctions against Poland.
The irony is that Poland was once the #1 or #2 power in Europe, but they were destroyed by unanimous voting. Want to raise taxes to build an army to repel foreign invasion? Everyone agrees, except that one person too far from Russia to care, and the taxes get vetoed, so Russia wins, thus Poland was destroyed. The Poles know how dangerous unanimity is.
What’s ironic is that Poland fought for years to become a member of the single market, after years of stagflation. They profited massively in terms of growth and wealth. Now after X years of membership they no longer want to play ball and think it is ok to corrupt the system. The same goes for Hungary after years of iron fist Soviet rule. It’s deeply tiring and begs the question whether the EU would be better without them.
What I remember from history lessons in school agrees with Wikipedia's description, so I'll just quote:
"Many historians hold that the liberum veto was a major cause of the deterioration of the Commonwealth political system, particularly in the 18th century, when foreign powers bribed Sejm members to paralyze its proceedings, and the Commonwealth's eventual destruction in the partitions of Poland and foreign occupation, dominance and manipulation of Poland for the next 200 years or so. Piotr Stefan Wandycz wrote that the "liberum veto had become the sinister symbol of old Polish anarchy". In the period of 1573–1763, about 150 sejms were held, about a third failing to pass any legislation, mostly because of the liberum veto."
"To give a minority a negative upon the majority (which is always the case where more than a majority is requisite to a decision), is, in its tendency, to subject the sense of the greater number to that of the lesser. Congress, from the nonattendance of a few States, have been frequently in the situation of a Polish diet, where a single VOTE has been sufficient to put a stop to all their movements. A sixtieth part of the Union, which is about the proportion of Delaware and Rhode Island, has several times been able to oppose an entire bar to its operations. This is one of those refinements which, in practice, has an effect the reverse of what is expected from it in theory. The necessity of unanimity in public bodies, or of something approaching towards it, has been founded upon a supposition that it would contribute to security. But its real operation is to embarrass the administration, to destroy the energy of the government, and to substitute the pleasure, caprice, or artifices of an insignificant, turbulent, or corrupt junto, to the regular deliberations and decisions of a respectable majority. In those emergencies of a nation, in which the goodness or badness, the weakness or strength of its government, is of the greatest importance, there is commonly a necessity for action. The public business must, in some way or other, go forward. If a pertinacious minority can control the opinion of a majority, respecting the best mode of conducting it, the majority, in order that something may be done, must conform to the views of the minority; and thus the sense of the smaller number will overrule that of the greater, and give a tone to the national proceedings. Hence, tedious delays; continual negotiation and intrigue; contemptible compromises of the public good. And yet, in such a system, it is even happy when such compromises can take place: for upon some occasions things will not admit of accommodation; and then the measures of government must be injuriously suspended, or fatally defeated. It is often, by the impracticability of obtaining the concurrence of the necessary number of votes, kept in a state of inaction. Its situation must always savor of weakness, sometimes border upon anarchy.
It is not difficult to discover, that a principle of this kind gives greater scope to foreign corruption, as well as to domestic faction, than that which permits the sense of the majority to decide; though the contrary of this has been presumed. The mistake has proceeded from not attending with due care to the mischiefs that may be occasioned by obstructing the progress of government at certain critical seasons. When the concurrence of a large number is required by the Constitution to the doing of any national act, we are apt to rest satisfied that all is safe, because nothing improper will be likely TO BE DONE, but we forget how much good may be prevented, and how much ill may be produced, by the power of hindering the doing what may be necessary, and of keeping affairs in the same unfavorable posture in which they may happen to stand at particular periods."
Eh, I wouldn't so much call it "abuse". Coming to consensus takes work. At a large enough scale, it won't ever happen, and the EU is much larger than that -- it's never going to meet any unanimity requirements.
Not sure what they were thinking with such a policy. Unanimity is something you can have at the village level.
> Poland and Hungary have found a loophole allowing them to ignore EU rules and sanctions while still profiting from subsidies and market access
AFAIK this was tit-for-tat: HU & PL closed/sold-off their industry in favor of WEU in exchange for subsidies. Removing these subsidies for any reason would violate the main economic agreement between them and EU. Mind you, there is no significant locally grown industry in those countries anymore (outside of a few state-owned industries), WEU profited from this enormously, especially Germany. As economic potential of this arrangement has been exhausted after 25 years already, incorporating UA is the next move to give EU (primarily DE/FR/NL) some nice economy boost for the next 10 years. EU is essentially playing Sim City.
Same playbook as with Greece -- which up to the 80s and the EEC had a larger industry presence, and discarded most of it with non-compete laws and the lure of subsidies in favor of the nothern-western parts of WEU.
Adding to that: one of the fundamental EU rules was freedom to do bussiness anywhere in EU. That worked in favor of Western countries which had their corporations opening offices in Poland, and making huge profits here.
After some time Poland found some niches for itself, e.g. Polish transportation companies dominate EU market in truck freight. What was the EU response to that? They recently passed change in labor laws, that would make this business unprofitable.
So: common EU market is fine as long as Western countries benefit from it, but Poland or other Eastern countries making money from business in the West is against the rules :)
What evidence do you have that the labor laws are a response to polish domination of freight, or that those laws would would somehow only cause polish carriers to become unprofitable?
It was explicitly stated by French president Macron, that the goal is to end Polish dominance in truck freight :)
Basically the law change is this:
Now, if you are Polish truck driver employed in Poland, you are subject to Polish tax and labor codes, including things like tax rate, minimum wage, etc. What France wants (and what was passed, but is not in effect yet) is that if said truck driver crosses the border of another country (say, France) he should be subject to that country tax and labor code. Which is riddiculous, because the driver does not change his tax residence, he just enters France for a few days it takes to make a delivery, and then comes back to Poland.
Would it also be ridiculous if a factory worker would be employed in one country and just cross the border to do a bit of factory work? All kinds of other local laws apply just by entering a country. How is minimum wage different?
Would it also be ridiculous if a factory worker would be employed in one country and just cross the border to do a bit of factory work?
It would be ridiculous, because the factory worker would be working at a company domiciled in the other country. That is because, a company in one country can not just open a factory in another country without having an entity in the latter country.
Consider an alternative situation: Franz is employed in Hungary as a writer of fiction, but crosses into Austria many days and uses wifi to work there. Should Franz be paid Austrian minimum wage?
All kinds of other local laws apply just by entering a country.
Local laws do apply, but generally one can not just enter another country and work there. Very often one is specifically prohibited from working in another country without a visa.
Except the stated goal of European Union is free movement of workers. You can literaly go and work in any EU country, no visa or work permission needed.
But that's not really the situation here: it's a business providing services for customers in another country. You send a driver abroad for a few days, that should not make him subject for local tax and labor laws. If you can prove that said worker spent significant period of time there (most tax treaties use 183 days as a rule of thumb) then that's a different matter.
You think e.g. Germany doesn't do the same with several satellite countries they play for with funds, trade deals, diplomatic pressure, and so on, to get a bunch of votes on EU matters based on their interests?
Hungary and Poland aren't the first to abuse the unanimous-1 veto.
The Netherlands always vetos Romania's application to enter the Schengen zone as Romania's harbors to the Black Sea will provide cheaper alternatives for import of goods to the Dutch ones.
Right, a port at the other end of Europe without good connections to the West, whose usage maybe makes sense only for ships passing through the Suez and Bosporus is a competitor to the ones sitting on the Atlantic.
And it doesn't have anything to do with the fact that the Romanian coastal surveillance system was conveniently down when cocaine started to shop up on the beaches.
I'm not sure about the merits of the original claim, but you can't dismiss the Suez like that. It's the connection you need between the Mediterranean Sea and the Indian Ocean and it lends itself to a ton of traffic: https://www.marinetraffic.com/en/ais/home/centerx:32.2/cente...
UN security council is another classic example, where any permanent member can use the veto to block any resolution they want, regardless of how the other permanent or elected members vote.
That’s by design. The council is kept small and all permanent members are nuclear powers. The ability for Russia and the US to veto each other’s foreign policy spats and agreeing-to-disagree is the reason we’re still alive today.
The _neu_-nuclear powers possess at most a few hundred warheads and lack true intercontinental delivery systems. They might kill a few million people but the damage will be localised.
All of the countries that could - and would (given the right kind of existential threat posed by another) kill a few _hundred million_ people in even a limited exchange are on the council.
There are other, non-nuclear states that could cause similar (<10m) deathcounts if they had a conflict. What we don’t want to do is frame the security council as “the nuclear club” which allows them to dictate global security - that would give states like DPRK and Hussein’s Iraq even more motivation to pursue a nuclear weapons programme.
To an extent it does come down to sincerity - I’m not concerned about India being a nuclear power despite it bordering Pakistan and PRC: I have faith in India’s democracy and stability to use their power responsibly (Kashmir is another discussion) - but I don’t extend that to DPRK who are clearly using it to avoid a Libya-type situation but who may end up using it anyway given the inherent instability of autocratic dynasties.
I obviously didn't mean all. India, Japan, Germany and perhaps a couple of others, such as South Africa and Brazil, deserve to have permanent status to have a more even security council.
It's more an economic issue than a nuclear issue IMO. And, I think the veto should be done away with.
Well if they believe similar things they vote accordingly. It's not a loophole, just two governments having similar views about those issues. It's for the better as well, if you allowed sanctions for refusing immigration policy you would end up with huge backlash and likely several countries exiting EU.
how does nobody talk about it? It's mentioned fairly regularly by commentators. Less than the italian deficit for sure, but still a well known fact.
If anything, few people mention the dutch trade surplus (I presume because the "netherland is evil!!" narrative is not as common as "german is evil!!").
Not true. The commission can chose to sue any memberships state in the European high court. Denmark was sued by EU for not allowing sale of tin can drinks (beers, soft drinks) in Denmark due to environmental concerns. It was seen as a kind of protectionism.
OK, but Poland and Hungary are far from the only nations ignoring EU rules (though they might be the only ones ignoring certain particular rules).
Take for example the Italian government's decision to run a deficit higher than what is allowed under EU rules (2% per year if I recall correctly). The EU tried to put a brave face on it: they held negotiations with the Italian government and announced a compromise, but it was pretty obvious to people who follow EU politics that the EU had no effective means to enforce the rule on Italy.
And this cap on deficit spending by governments of member nations is no minor rule. Many had stated over the years since the introduction of the Euro that the rule is necessary for the single currency to work.
I don’t understand how the org let that happen... Does someone know or have articles about it? I can believe that they left the unanimous vote and then had the good idea to invite Oracle at the table without some
Power play behind it.
I bet Oracle will have its MS pivot moment,
sooner that we think,
to face AWS, PostgreSQL, IBM/Red Hat, Pivotal Spring offers...
But it was a lot of time wasted:
Apache Harmony/Java
LibreOffice/OpenOffice
MariaDB/MySQL
Jenkins/Hudson
now Eclipse/Java
Right now, they are in sales hurry mode, calling at all occasions technical contacts each time you create a new account to download something on their web site...
> the worst case possible, as it not only voids the “WORA” (Write Once Run Anywhere) principle, it simply won’t happen in reality: After 18 months virtually no application vendor really wants to spend the time and money to update all customers with recompiled versions just for the sake of a renamed platform with a dubios future.
WORA was never perfect, I would be surprised if there was even a single JRE release that didn't note a breaking change in its release notes. So vendors should have a process to update their releases just for that already in place.
> The future is unclear because Oracle already started a blocking politics at the Eclipse Foundation’s board, where Oracle has a seat, and where unanimous decisions are needed.
They have no rules to out board members acting in bad faith?
Well, mmm, good riddance? I suppose this will cause a lot of hardships to a lot of people who need to maintain JavaEE, but the fact that Java EE is no more is nothing but good. It is a nightmare case of overengineering.
I never used a flow blown Java EE web application server, but the various APIs I used like JDBC, JAX-RS, and JPA were generally well thought out and pleasant enough to work with. It would be a shame if these interfaces/specifications became proprietary.
Without knowing it you have cherry picked possibly the only good parts of Java EE. The rest that constitute a 'full blown' Java EE stack are horrific disasters (JSF, EJB, etc).
Would you mind showing any platform's solution to the problems that java EE solves?
I have yet to see any competitor technology solve transaction management as elegantly as EJB's does.
I switched to C# late last year. Oracle is just too much baggage to have hanging around when thinking about your career / future for me. Really didn't like the direction they are taking things when they announced their new release train and licencing model. Compared to that Microsoft have done an about face in recent years with a commitment to open source and first-class support for Linux and revamping their core offering with .NET Core. It's been a mostly smooth transition.
JVM is still the best platform for any type of back-end application. It has the widest array of libraries, is proven to run on any type of hardware and comes standard on every OS and every cloud instance.
.Net is a great platform and all but it still hasn't done enough to really merit switching teams. Especially when you have Scala, Kotlin, Clojure etc to pick from.
Java doesn’t come standard on Windows, MacOS, or iOS. It’s also not standard on Windows based EC2 instances.
But even if it does come “standard” on Linux. How many people actually count on the installed instances of runtimes and don’t install their own tested versions?
For instance, Python 2.7 comes on a Windows EC2 AWS instance.
The parent post said “and comes standard on every OS and every cloud instance”. That is not true.
I brought up Python as an example of a language that does come “standard” on “cloud instances”(and MacOS) but it’s an older version. Most people wouldn’t count on the bundled version of either.
hand up uh not as experienced as most people on HN, what's the hate for c#? I went from vb6 to VB.net then c# and while I fully admit I'm a casual coder, i haven't had an issue (with what I do, which is voice to string primarily) so far. Is there something better for this I perhaps should look into?
The .NET ecosystem is an order of magnitude smaller than the JVM ecosystem. Up until ~3 years¹ ago C#/.NET also meant a fully Microsoft and Windows environment for all practical purposes². This is changing and Microsoft seems to be embracing open source and Linux, but it takes time for a 20 year old ecosystem to fully make the transition.
¹ The story is Steve Balmer was very anti-open source and forbade most interop or support for Linux, so this only could start changing when he left in 2014.
² You always had Mono with is why Unity and GNOME could also use C#, but is was very niche outside of Unity.
That fully Microsoft and windows stack has had ripple effects. At least from my perspective in South Asia. First the price was a deal breaker. Second, people who started with C# quickly found their only employment opportunities to be at large companies. Those who started with Java/Node/Ruby had a much wider array to choose from. Third, when people jumped to start their own companies, Java/Node/Ruby/Python/Go won by a large margin. Startups rarely had the cash to spare for Microsoft stack and MS stack guys had to change their skill sets which is a painful endeavour in and of itself. Fourth, after some time people, who had been in the market for years, started discouraging younger devs to committing exclusively to a full MS stack. People rather interpreted it as dumping the MS stack. In my batch, only a dozen or so people were interested in pursuing C#/.Net. By the time we graduated only one person was still pursuing that stack.
TLDR; Price was a big factor which only large companies could afford. Not everyone can be employed by large companies. This had a lot of secondary effects.
Funny you should say that because it was Sun Microsystems itself which caused me to switch to C#. Starting out in my career I worked for serial entrepreneurs exclusively to learn from them and one such company used Sun Java for their main product. Hello there! Every time the Java development chatroom crashed for a couple years or so it was me who started it back up. The company I worked for provided that chat software. Sun was not happy with the performance and sent us a letter citing the GPL demanding we host, at our expense, the server for their chats and also a 10 point response plan for turning things around. They claimed that since we used Java our IP was theirs respectively and we were now unpaid employees of Sun. They did not take our revenue (although that was never off the table) but they did assign a tech writer to scream at me over the phone whenever it went down. This “product” was written by a teenager for a coding contest we did and that developer received ~100$. Those agreements you sign off on when installing Java are all about that and sooo much more. This article is about the same thing happening once again under Oracle. Be careful what you agree to- anything I do Java related anymore is OpenJDK. TL;DR here is Java is not evil in itself but the licensing around it certainly is.
This sounds very unlikely. So SUN Microsystems claimed that you should run service for them because of GPL that had classpath exception? Even without that exception that is not how GPL works.
That's a very interesting view point, thanks for that. I hadn't considered it from that point of view.
Back when I was learning code(early high school) it was qbasic, HTML and c++, once I was able to afford a cheap pc I learnt via scripting (for Ultima online free servers).
I guess it's a big difference between learning for a job and learning for fun(pre-job that is). Which it seems I have kept on the years after haha.
Hmm thanks for the info, I'll admit I haven't used pretty much any ecosystem outside of windows (aside from my new jobs Mac which drives me nuts(non coding job)), but haven't had a need to install any variant of Linux.
Which still leaves me a tad confused, is the anger because c# is a propriety windows tech(I'm guessing from the responses - which btw thank you to the threads I don't respond to).
The anger is a "red vs. blue" mentality. They're Java developers, they always have been, and they always will be. They still think Microsoft--the EEE Microsoft of years past--somehow relates to their (Microsoft's) development tools and platforms org. It doesn't.
Things aren't "changing," they've changed already. .NET Core is more than stable enough to run on any major platform and has been for quite some time now. C#--especially the upcoming C# 8.0 with the new nullable reference types feature--is an excellent language that can handle anything you want to throw at it.
They have certainly changed – the .NET installer used to ask if you wouldn't mind participating in their product improvement program by sending data to Microsoft (defaulting to disabled by default), but now .NET Core will send your data to Microsoft by default without asking:
The data is supposedly anonymized, except sometimes (according to comments on above-mentioned issue) when it accidentally isn't. You can also disable it, except when the disabling mechanism is accidentally broken.
It used to force you to a Windows only stack which can be problematic in a server based app. Its much easier to manage linux servers even if you just look at it from an OS license perspective.
I don't think there's hate for it as such since HN doesn't really get into holy wars it just ignored for similar reasons to Java. There's a bias towards the novel or newer trends especially coming out of startup culture which means limited interest in the established workhorse languages, C#, Java and to a lesser extent C++ when compared to Rust, Go, etc.
I only write C# despite having tried a few other languages (F#, Python, Java, Elixir, etc) because I'm not prepared to invest the time in languages until the tooling is as productive for me as C#. I'm more interested in what I want to do than how to write it. Both C# and Java remain big in the market here in the UK and I believe in the US; you just might not find work at the cutting edge with them.
Hate is not but the verbosity of java meant that you cannot afford time to type or read those statements. And the complexity. When you start up and/or hack, you are 1 p or small group. Java enterprise is not really an option. I need to move to phase 3 before I ask the team to switch to spring and JE side. Painful. But can we do it first with those. No way. And for personal project :-)
Yes I can certainly understand the reasons startup culture leans towards the less verbose less boilerplate demanding languages.
For me, my short term memory is too bad for languages without types and autocomplete on the level of JetBrains products.
I feel like C# specifically (I don't have any real Java experience) is a lot lower on boilerplate now and I can usually get a working prototype of something together in a day or two and it allows me to target games, desktop, mobile, Web, ML, etc. But it's not to everyone's taste and that's fine.
To the downvoters. Really? I'm literally asking why here, while my karma is really a non issue, I'm wondering why you would down vote an honest question. (Thanks again to the people who gave me informative posts, I have some things to research, just need to find the time!)
your comment is back in the black now, so I'd say generally don't worry about these things. A lot of people reflexively downvote stuff, but in many cases this is correct within 12h or so. That's been my experience most of the time, at least.
Complaining about it is often brutally punished by more downvotes though, so beware!
Most of the hate around C# stems from Ballmer-era interoperability blocks, specifically some hot / cold dithering on the work Mono was doing to make it truly cross-platform.
Hmm I hadn't really considered cross-platform(as I mentioned above aside from a forced forey into Mac ATM dur to work, I've always been windows).
I'm thinking perhaps I should take some primers on non windows coding, and the advantages there of. Anyone have any good beginners links (note I'm fairly adept at Java, .net, vb and such, just trying to find a good place - and reason - to learn something cross platform).
Pre:edit: I don't mean this to sound argumentative about platforms, just honestly looking for some good resources (and I'm fairly time constrained)
Perhaps the biggest 'bang for your buck' would be Javascript or Python. The former because it's everywhere, and the latter because it's almost everywhere and probably more pleasant than the former. And possibly better if you're time-constrained, because you could pick one of the areas where it's a staple.
Either way, both are quite un-windows, and un-corporate, but used all over the place. I'm suggesting them because, as someone who hasn't been part of any 'corporate' ecosystem since Delphi (to the point where even Java is 'too corporate'), I've been meaning to dip into the 'less sexy' world of Java/Delphi/C#/.Net/VB just to find out what it's like.
I'd very much like to hear your thoughts if you decide to check out this side of the fence, so by all means do so and write a blog post about it (or send me an email and perhaps we could write a dual-author post about our respective experiences someday!).
Actually (about 7+ years ago?), I did dip into python and wrote a stock taking and auto order generating system for one of my kitchens in it, never really got the chance to revisit it after that though. I do remember how surprised I was at how quickly I got it done (I was coming from vb6 at the time).
I may have some automation things I can do at my work soon, I might write up a blog about that, interesting idea! (Queue the 'if I only had more time' chant haha)
If you're into IoT type stuff (or other real-time thingies) I can also recommend Elixir. It's my current favorite language and very good for these things (https://nerves-project.org/).
The downside is that it's not a very mainstream language. The upside is that it's arguable one of the more 'unique' languages out there (alongside Erlang), and IMO just really fun.
First C# needs to get into all the platforms where there is a Java compiler.
And a proper story for something similar to Swing, not even considering JavaFX here. There is Xamarin, but again, the platforms with Java compilers available.
And I am stating this as someone that works daily within .NET eco-system.
The correct way to ask this is "which platform that matters doesn't have a Common Language Runtime?" The C# compiler generates Intermediate Language, not native instructions (.NET Native is an exception to this, I believe, but don't quote me on that).
Java cards use a very limited version of Java, I would not put it in the same category. You can't just take your average random java code and run it on a java card.
Mainframes, factory automation platforms, embedded hardware for M2M communication, phone centrals like the ones from Cisco, Bluray Players, electricity meeters with network capabilities like those from Gemalto, car infotainment systems, smart cards, copiers like those from Xerox and Ricoh,military equipments, ...
And plenty more.
It is not that is impossible to have them as .NET deployment target, just that right now, those industries don't care about it.
I think every Java developer should be familiar with C# and dotNet Core. There is a lot of similarities between the languages and it will be easy for any Java developer to pick up.
If you're looking to get into C# 8.0 you're out of luck if using OS X. Visual Studio 2019 for Mac offers .Net Core 3.0 as an option if you have it installed but Mono hasn't caught up with C# 8.0 so isn't available. So much for cross-platform development - it seems OS X is still an afterthought.
Download Visual Studio for Mac 2019 and you won't find C# 8.0 listed under the project's language options. I'm referring to the Mac here where I understood Mono is still the way .Net Core is implemented.
Honestly I'm not joking, but I am a casual coder. I have only learnt what I need to do, to do certain things. Which compared to most here isn't that much. (See my other responses, I'd actually love some input there, just wish I had more time to learn)
Edit: as to the reference to the last part of your comment, I have only been using what I knew to do the job I needed, I'm not a full time coder so I can't search the latest and greatest, another reason I picked this thread to ask :-)
(you're correct to an extent) I learnt c# to do what I wanted in my free time, I haven't had time to look into alternatives. C# does what I need, and I either work out how to do what I need with that, or I can't do it (I'm not a full time coder, so I don't have time to research, learn and recode what I have done to something new)
Any organization that bought into JEE is probably willing to pay Oracle's license fees. That being said, I've literally never seen an org that preferred JEE to Spring and that includes numerous massive enterprises.
A lot of the good parts of the JEE were inspired by Spring, which can go ahead with ideas without needing to go through the JCP. There's a cyclical relationship between them.
Disclosure: I work for Pivotal, we sponsor Spring.
In the early 2000s I did a lot of work with ATG Dynamo which was a proprietary Java app server. It was light years ahead of the top competitors (WebLogic or WebSphere back then). It had dependency injection, clear separation of logic and UI, a handy runtime inspector GUI that let you inspect the state of all your container-managed objects including user sessions i an real-time and modify them. The original J2EE borrowed heavily from it and ruined it.
>But once Eclipse products would be not vendor-neutral anymore, the EF’s tax exemption might become void, which would mean a financial fiasco, or possibly mean the end of the organization as a hole.
I think the problem is Oracle's a-hole, in this situation.
"As you know people, as you learn about things, you realize that these generalizations we have are, virtually to a generalization, false. Well, except for this one, as it turns out. What you think of Oracle, is even truer than you think it is. There has been no entity in human history with less complexity or nuance to it than Oracle. And I gotta say, as someone who has seen that complexity for my entire life, it's very hard to get used to that idea. It's like, 'surely this is more complicated!' but it's like: Wow, this is really simple! This company is very straightforward, in its defense. This company is about one man, his alter-ego, and what he wants to inflict upon humanity -- that's it! ...Ship mediocrity, inflict misery, lie our asses off, screw our customers, and make a whole shitload of money. Yeah... you talk to Oracle, it's like, 'no, we don't fucking make dreams happen -- we make money!' ...You need to think of Larry Ellison the way you think of a lawnmower. You don't anthropomorphize your lawnmower, the lawnmower just mows the lawn, you stick your hand in there and it'll chop it off, the end. You don't think 'oh, the lawnmower hates me' -- lawnmower doesn't give a shit about you, lawnmower can't hate you. Don't anthropomorphize the lawnmower. Don't fall into that trap about Oracle." -- Bryan Cantrill
> And the idea that corporate developers or even frankly any developers are switching to LLVM and WebAssembly en masse is pretty ridiculous.
There is only 1 popular language released since 2009 that targets JVM: Kotlin. All other target JS, their own bytecode or LLVM: Go, Rust, Dart, Elixer, Julia, Typescript, Swift.
This is a significant difference from 2003-2009 languages which all targeted JVM unless they were Microsofts: Groovy, Scala and Clojure.
>Because development that happened in 1994 is really relevant today.
1994? We still depend on tons of features, infrastructure, and techniques developed in the 60s and 70s.
Heck, most of what the JS world considers "state of the art" was already available in 70s languages.
As for the snark, first, the innovations the parents refers to is not "JavaBeans, Java Server Pages, and Java Server Faces", but stuff like rock-solid GCs, tooling, and so on.
And even techniques on the level of "JavaBeans, Java Server Pages, and Java Server Faces" are only going to be resold to several other languages. The JS worlds keeps on piling Java (or older) techniques and syntax.
Heck, they just re-invented the "private instance variables" (with an ugly hash syntax) on their latest efforts...
The contention was that other languages had a “lot to catch up” with Java because it’s been around for 25 years. So how haven’t other statically typed languages “caught up”?
In fact, Java is so far behind C# with true Generics, LINQ - not the syntax the entire linq expressions -> expression trees -> runtime providers that can parse the trees and translate it to a destination syntax, etc. it’s laughable. Can anyone say honestly that Oracle has been a good steward over Java or that it has improved as fast as any modern popular language?
And the “tooling” around Java is the main reason that when I had a choice between C# and Java in the mid 2000s, I chose C#. Heck, the Visual Studio 97 was better than most Java tooling is today.
Yeah I played around with the early VB like Java IDEs like JBuildsr. Java’s IDE’s have never been strong points. Neither have the XML is king mindset.
Here we go again with "true Generics". Type erasure makes interop easy (for an almost insignificant cost), including with Java prior to generics. But that's also what makes different languages on the Java platform interop so well (contrast with the CLR, where this is not the case; they've baked variance into the runtime and are paying a high price for that decision). If Java had baked their type system into JVM, Scala, Kotlin, Groovy would have to dance around that. Haskell, for example, erases all types, not just type parameters (well, sort of; it does reify the constructor tag/discriminator, which corresponds to type information in Java), and people get fancy with types in Scala, too. The only real annoyance erasure brings is that you cannot overload a method with another that erases to the same type.
All in all, The JVM is leading not only CLR on all fronts, but pretty much any other runtime. C# compilers and GCs are at least a decade behind Java's. You may argue on how important those things are compared to other tradeoffs, but those are the areas where Java was designed to compete at, and those are the areas where it is leading by a wide margin.
Edit: when Java was first introduced, its original designers stated their intention to construct a conservative, low-innovation frontend language, and a high-innovation runtime. In many respects, .NET has the opposite design. You may prefer one or the other and that's OK, but it makes comparing the two on any single aspect very problematic. Of course Java won't keep up on language innovation compared to .NET, and of course .NET won't keep up with Java on runtime innovation -- they each choose to get their competitive advantage in different aspects.
Seeing that generics have been around since 2005 in C#, I think the .Net community has had plenty of time to work around the incompatibilities....
There are other languages that support CLR besides C# and they manage to “work around” generics.
All in all, The JVM is leading not only CLR on all fronts, but pretty much any other runtime. C# compilers and GCs are at least a decade behind Java's. You may argue on how important those things are compared to other tradeoffs, but those are the areas where Java was designed to compete at, and those are the areas where it is leading by a wide margin.
Also, I am very interested to see new benchmark results once AOT SubstrateVM will be more widely adopted in JVM community. Demo: https://youtu.be/MN6jNIwl2FQ?t=1136
RedHat already working on a framework which takes full benefit of that: https://quarkus.io/
All in all, with upcoming value types, SubstrateVM adoption, fibers and nice languages improvements like records, future is brighter than ever for Java.
What exactly in BoyRobot777's comment (which I said I agree to) calls for benchmarks to be proved?
Nowhere are benchmark results taken for granted as faster or anything. Grandparent says: "Also, I am very interested to see new benchmark results once AOT SubstrateVM will be more widely adopted in JVM community."
I simply agree with the statement made: "All in all, with upcoming value types, SubstrateVM adoption, fibers and nice languages improvements like records, future is brighter than ever for Java." -- so, I responded to your comment which seemed to be skeptic of that (and accusing the parent of working for Oracle).
If you were referring to someone else and some other comment, why post your comment as a response directly under BoyRobot777?
>In fact, Java is so far behind C# with true Generics
It's not "true Generics" it's a different generics tradeoff (tradeoff not just for backwards compatibility sake).
And LINQ is not that important in the grand scheme of things. Are Haskell, CL, or Smalltak also "far behind" C# for not having LINQ? It's just another feature. You can most of the same things with a fluent interface, streams, and functional composition, and without straying off the regular syntax of the language into a LINQ DSL.
Besides, last time I've checked, Java still has the performance edge over C#.
LINQ itself is a big deal because of what it enables.
A simple LINQ expression can be passed around an translated on the fly by various providers. The same expressions can be translated to Sql, Mongo, regular IL, etc.
And no LINQ isn’t just syntax.
Last time I checked neither SmallTalk or Haskell are taking the world by storm...
Haven’t Java proponents been claiming Java was going to be fast for over two decades?
>A simple LINQ expression can be passed around an translated on the fly by various providers. The same expressions can be translated to Sql, Mongo, regular IL, etc.
The same can happen with a simple abstract expression in native syntax (in fact tons of tools in all languages that do that). LINQ just gives you a standardized built-in DSL for that -- but nothing you can't build yourself with the language's main syntax. Heck, LISPs have been able to do the same shit for half a century.
>Last time I checked neither SmallTalk or Haskell are taking the world by storm...
Yes, they only made a dent with the smarter developers.
Still, C# isn't taking the Linux world by storm either, and it's nearly irrelevant on mobile too, so there's that.
>Haven’t Java proponents been claiming Java was going to be fast for over two decades?
Java has been fast for over 15 years now, so not sure what you're getting at here. Faster than C# as well, so there's that too.
The same can happen with a simple abstract expression in native syntax (in fact tons of tools in all languages that do that). LINQ just gives you a standardized built-in DSL for that -- but nothing you can't build yourself with the language's main syntax. Heck, LISPs have
Okay so where is it? What language besides some .Net based languages allows me to take the same query expression and have it interpreted differently based on the provider and allows me to switch out an RDMS or Mongo for example without changing the calling code?half a century ago I wasn’t even born (about 5 years later). Saying Lisp did it 50 years ago is about like Mac users bragging in 2019 that they had a GUI before PCs.
As far as LISP, what are the job opportunities like in 2019?
Yes, they only made a dent with the smarter developers.
Can I make money with those languages?
Java has been fast for over 15 years now, so not sure what you're getting at here. Faster than C# as well, so there's that too.
So just in case I want to work for the one anecdotal company that uses Lisp I’ll keep that in mind...
But seeing that I like the optionality of working for any of the dozens of companies that have job openings continuously for JavaScript, C#, C, C++, and even Python, I think I’ll stick with those....
There is a big difference between choosing the less popular but still marketable technology and someone doggedly sticking with a technology that has being put in maintenance mode by the vendor or in the case of Lisp, a minuscule market.
afaik c#'s "true generics" as you call it imposes a runtime cost due to code generation because the compiler doesn't necessarily know all specializations aot. haven't looked into it in a long time though.
as far as ides go, i vastly prefer intellij to visual studio.
Eclipse was slow and had the usual non native Java smell that all cross platform GUIs have - especially on computers back then. But even now, Eclipse is sluggish compared to Visual Studio.
>Eclipse was slow and had the usual non native Java smell that all cross platform GUIs have
Actually Eclipse used a native GUI toolkit (Standard Widget Toolkit), backed by native widgets plus a few custom draw ones (like 100% native apps also resort to for custom stuff).
So, if it smelled "non Native", it wasn't because of Java.
There were no "performance penalties" to speak of related to the GUI layer. IDE UI is not doing anything crazy to be performance bound. And I've (like millions of others) have used it in 2003-era PCs, with spinning platter HDs.
What indeed was, were some penalties of the GC kicking in (unrelated to UI widgets). Still nothing a .NET app wouldn't have (and I've used SharpDevelop as well back in the day).
Considering that we're watching the javascript ecosystem slowly fumble its way through reinventing the technologies of the past, I'd say 1994 is pretty damn relevant.
Types. Clumsy stand-ins for synchronous behavior like async/await. Transaction managers. Threads. I'd add immutability and functional programming but really that's rediscovering technology from the midcentury.
Yes I know they exists. But my definition of “good” is does look and work like a native app? That’s not true for anything Java based or Electron or .Net.
They are far from catching up on compilation, GC and low-overhead observability technology. Those developments didn't happen in 1994; they have been happening continuously over the past 25 year (e.g., in the past few years we've seen ZGC, JFR and Graal), where Java is still far ahead of the pack.
I don't know where you're getting the 1% -- in some of those benchmarks it's much higher (and remember that Scala and Kotlin are also Java -- they rely on the same compilers, GCs and monitoring; they just replace the frontend compiler, which is less than 10% of the JDK). Also, the benchmarks are very simple, and hardly exercise the platform's power. And they don't measure other capabilities at all. For example, Go may not be far behind on performance, but its observability is shit, it doesn't have good dynamic linkage, and other important features.
Again, I am not saying that other platforms may not have advantages elsewhere (e.g. lower memory footprint, no warmup), but when it comes to compilation, GC and observability, Java is about a whole technological generation ahead.
You seem to think Cobol is somehow superseded now. In fact it runs more critical infrastructure, and even sees more lines per year added for those kinds of systems, that JS does.
And who uses Dart? Elixir? Julia? Hardly anyone. Lots of attempts but also lots of failures, sometimes due to poor runtimes or libraries.
Swift is iOS/Apple specific, at least in usage. But mobile is dominated by Android, which is moving towards Kotlin. So Kotlin is already huge right there, much larger than Dart or Elixir and probably larger than Swift, soon if not already.
Meanwhile Go would probably benefit from targeting the JVM, or at least having the option. As is, it's stuck in its own isolated world with low quality tools, libraries and GCs.
At any rate number of languages is an odd metric. Kotlin by itself is a good enough language to probably kill off most attempts to compete with it over the next 5-10 years or so on the JVM, outside of research languages. Does the JVM really need dozens of languages?
A lot of new languages fail. It's still a good measure of where things will be 10-20 years later.
Look at new languages of 1990-2000: Haskell, Python, VB, Lua, R, Ruby, Java, Delphi, JS, PHP, Rebol. 4/11 are mostly irrelevant now. 4/11 are important niche languages. 3/11: Python, Java, and JS are dominant players.
1990-2000 might be special because of a massive shift toward IT systems in general, but it might not be and be an indication of languages lifecycle.
> stuck in its own isolated world with low quality tools, libraries and GCs
"Go needs a native library for ___" is used as an opportunity for safely tedious résumé-driven development. On the JVM you'd have to look for an unsolved problem which is probably harder.
If I understand correctly, OpenJDK is licensed under GPL with classpath exception - and the only thing that is preventing openjdk from being unusable in any commercial settings is a few lines of legalese, controlled by Oracle, on handful of source files in various packages. If Oracle removes that classpath exception legalese in some upcoming jdk version from these source files (which they are fully in control of), openjdk essentially becomes GPL-only.
I guess then openj9, coretto etc would be more appealing but soon enough it feels like there will not be Java left - since those distributions don’t/can’t call themselves java unless oracle allows them to... and I’m not sure why they would - as apparent by OpenJ9 not being called java.
The JDK would promptly be forked from the last-covered commit, presumably by a coalition of Amazon, Azul, IBM, Red Hat, SAP, Google, Microsoft (amazing times we live in) and Pivotal amongst others.
What enterprise customers want is certainty. Given the choice between "Java by Oracle" and "Basically still Java by Literally Every Other Enterprise Software Vendor", they will pick the latter in a heartbeat.
It would be chaotic and disruptive, but once the dust settled Oracle would (again) be holding the fizzle instead of the bang. That's how we got Jenkins out of Hudson, which has an unrivalled penetration of enterprise.
Disclosure: I work for Pivotal, we sponsor Spring and have a deep interest in the evolution of the OpenJDK. This is of course personal speculation.
Possibly, though it would kill Oracle's Java business even more thoroughly.
If their business strategy is more nuanced than "cut your own throat in the hope someone else's is behind it", then political jiggery-pokery like Java EE is probably about as far as they would want to go.
Oracle is not letting them test builds with the Technology Compatibility Kit (TCK https://en.wikipedia.org/wiki/Technology_Compatibility_Kit), which under Sun probably killed the Apache Harmony project. There are alternatives like Amazon's Corretto and Azul's Zulu.
You can't revoke a GPL license unless the licensee violated the GPL. Additionally, the GPL has this nifty "Automatic Licensing of Downstream Recipients" clause. In other words, if you put some code out there under the GPL, there is no way for you to un-GPL that particular code. Even if you bring out a new version of it that isn't GPL any more, the old version still is. (This is quite important to make copyleft work)
It sounds like the parent's issue is the other way, that Oracle might remove the classpath exception and then GPL would infect everything, effectively killing commercial opportunities.
> You can't revoke a GPL license unless the licensee violated the GPL
Probably true for GPLv3, because GPLv3 actually says that it is irrevocable. OpenJDK is under GPLv2, which does not say anything about revocation. It is an open question whether or not GPLv2 can be revoked.
> Additionally, the GPL has this nifty "Automatic Licensing of Downstream Recipients" clause. In other words, if you put some code out there under the GPL, there is no way for you to un-GPL that particular code
That clause actually makes it more likely that GPLv2 could be at least partly revoked, because the full text is:
> Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor [...]
It's that "original licensor" part that makes partial revocation a possibility.
What if the original licensor simply says that they are no longer granting new licenses? Everyone who already has a license can continue to use the software, but new recipients no longer can get a license? (That's what I meant by "partly revoked" earlier--existing copies remain OK, but the spread of them, or derivative works of them, is stopped).
What happens then is a mess. Even figuring out who has standing to sue to try to make license issuing continue is a mess, getting into such questions as whether the unspecified future downstream recipients of copies are intentional beneficiaries or incidental beneficiaries of the contract. (And then there is the whole "is this a license or a contract?" issue which is very murky).
BTW, even licenses that do say they are irrevocable might suffer from this partial revocation danger if downstream recipients must get their license from the original licensor.
The fix to this is to allow sublicensing in your license. Make your license irrevocable (so that once someone gets a licensed copy it cannot be taken back), and allow sublicensing so that when someone distributes a copy the license for that copy comes from them rather than you. Then if you stop issuing new licenses there is no problem, because people get their licenses from their distributor.
If you don't want distributors to be able to give their downstream less rights than you gave them by only sublicensing a subset of those rights, you can put in the license a clause that requires distributors to sublicense all the rights.
A nice side effect of the sublicensing approach is distributors have standing to sue for license violations. Under the GPL-type approach, where all licenses are directly from the original licensor, only the original licensor can sue to enforce the license. Under the sublicensing approach, both the original licensor can sue (alleging copyright infringement) and the distributor can sue (alleging violation of the license).
They still did a ton of cool stuff after that. It was under Jonathan Schwartz that the lack of direction and the overwhelming confusion became painfully obvious, not knowing whether it was a software company trying to profit from and compete against free (as in beer) software, a hardware company narrowing its own niche at the very top or... something totally different.
To me this seems like a play against OpenJ9 which is at least partially based on OpenJDK. Rumor has it that AdoptOpenJDK lost their TCK license because they also published OpenJ9 builds.
I'm a bit surprised by this given that IBM is a long time license holder and I can remember JavaOne keynotes where Oracle celebrated IBM "joining" OpenJDK.
> At this stage the London Jamocha Community CIC (aka LJC) has not been able to reach an agreement with Oracle to use the Java SE Technology Compatibility Kit (TCK) under the terms of the OpenJDK Community TCK License Agreement (OCTLA).
> We will continue to work with Oracle on this matter.
> All AdoptOpenJDK binaries are tested with our suite of functional, integration, stress, and performance tests, including real workloads from popular languages and applications. We are very confident in the quality of our builds.
Oracle fights with the open source community and loses, again. They just keep repeating the same mistakes over and over. What always happens is the Open Source people say "screw Oracle" and fork the project and the community comes along with them.
The Hudson/Jenkins and OpenOffice/LibreOffice fails were two of the quickest and most obvious. Java EE seems like the same sort of thing, but much bigger and in slow motion.
Dumb question... Wouldn't it be possible to fork the namespace to something like javax -> jawax (or java->borneo as someone suggested) and then patch the JVM to alias the javax package to the would-be jawax package (or borneox or whatever) ?
The other option is a maven plugin that lets you rename packages and then someone posts a list of rules on a StackOverflow question for renaming the new namespaces to the old ones: that way, no JDK distributor is distributing software that understands the old package names.
Maybe have a more sensible namespace convention. Presently, for any given API, it's a toss up of whether it's under javax.* or java.*, with no rhyme or reason.
After Java SE has become proprietary-like software, it was reported that Java EE division would be handed to the Eclipse Foundation. And that was good news because it meant that Java EE would be managed independently from Oracle but now we see that Oracle wants to make Java EE dependent on themselves, and that is bad news :::
I propose to mimic the intended move of the Indonesian government to move the capitol from Java to Borneo by forking OpenJDK/Java to OpenBDK/Borneo.
If Oracle wants to keep the Java(tm) trademark, they can keep it.
Yes. The Java ecosystem is far larger than Oracle. Java can absolutely thrive if Oracle were to cease to exist tomorrow, or if everyone else[1] decides to move to a fork.
Pivotal is hiring for JDK/JVM development. Worldwide. If you're at Oracle and you want out, drop me a line or do a search for "JDK" at https://pivotal.io/careers/openings
Several companies outside Oracle already employ JDK folks (IBM, for example). I expect that increasingly our partners and competitors will do the same.
That Oracle employees are the dominant contributors today is only evidence of the state of the world today.
Oracle is not owed indefinite fealty by folks locked into serfdom. Everyone working on the OpenJDK is entitled to work on it with someone else paying them.
Current contributions are besides the point, when Netscape open-sourced their browser, the Mozilla Foundation didn't even exist prior to that moment. Java without Oracle is viable - I dare say a "Java Foundation" would be an improvement in terms of community involvement, and there are candidate companies with vested interests (and excellent engineers) to join one should it ever come into existence.
Oracle has a history of not being great at dealing with the wider open source community, not just related to Java: look at how it handled Open Office.
Are new systems being constructed in Java .. when starting on new projects Java was at one time (about 6-8 years ago) the leading alternative for Corporate IT (if they weren't a Microsoft shop). I doubt it very much.
Oracle is playing this not-so-good role, that Microsoft used to play, under Steve Ballmer, monopolistic, and evil.
I found Java hideous, the gratuitous OOP taken to extremes put me off. Spring came in, and you had class names that were a hundred characters long - your actual line of code was shorter than the class name. The problem with Java (and every programming language has its own achilles heel) - is everything has be class oriented - however much you try to bolt on, on top of that , to make it seem not so. . Java kills creativity, and expressiveness in software by its bloated syntax and OOP. We took up Java because at the time alternatives were few, but now its on its way being the new Cobol - this will sound ridiculous if you still are fully or partially, inside its bubble
I ran from our Java shop. My software architect mocked me "you'll be back in 6 months" - instead, he quit the Java shop and stuck his head outside of the Java bubble and realized there was life outside.
We all love Java, however we need to decouple the Language from the ecosystem that the new owner of Java, Oracle, wants to enforce upon customers.
Oracle made a clear business decision and will go forward squeeze every single dollar they possible can thru legal means, not from innovation or services.
How are they squeezing dollars here? They don't seem to be demanding payment, or at least not directly.
I read the board notes. This appears to be a disagreement about trademarks and compatibility licensing. To be called "Java" you need to be compatible with the Java specs, and also have a trademark license. That's how they enforce that the platform can be reimplemented but it's seamless to users. Seems Eclipse Foundation doesn't like that.
> how hard will it be to work out a script, that update the namespace automatically? it would even be possible to do that in the bytecode level I think.
Java has reflection, so classes can be loaded by name at runtime (and the name might have come from a XML file somewhere, or be the result of string concatenation); also, the name of a class can be easily obtained so code can depend on that (for instance, a logging configuration XML file). That's before considering that some libraries generate classes on the fly (by dynamically generating and loading bytecode, which include class names).
The world is moving on from .Net Framework - including Microsoft. .Net Framework is definitely the new COBOL. It’s basically in maintenance mode. Any company would be crazy to start a new greenfield project using .Net Framework and should have some type of plan to move to Core.
The presenters said it will still be released with Windows, as it's a component of Windows itself, so it will be supported for the lifetime of Windows. Microsoft is just going to be making highly compatible targeted improvements to .NET Framework after version 4.
So you shouldn't feel pressured to move off .NET Framework, but just know that it's going to be much more highly targeted compatible fixes kind of going forward and we recommend that all new development that you start on .NET is on .NET Core if possible
So instead of tying your horse to one dead end platform - .Net Framework - you’re okay with tying your horse to two? It was clear that C++/CLI was a dead end a decade ago.
When Microsoft mentions thier “strategies” for various .Net languages, you notice which one is missing?
I’m very much a .Net fan but it makes about as much since as a developer to tie your fate to .Net framework or Windows only development in general in 2019 as it did for all of the companies not to move from VB6 after .Net was the future.
So it’s “religious” not to tie your career to a platform that the vendor and the market are both moving away from? If I chose my language and technology choices based on what I like and not marketability, I wouldn’t be going near React, Node or any of the cool kids stuff.
I would rather not end up like old VB6 developers trying to find a job in 2008.
I know a developer who worked in a company for 20 years got laid off and complained about “ageism” because no one would hire him and all of his experience in 2017 was in Windows Forms and Web Forms.
Yes, I’ve been there done that too. Mid 2008, I had been at a company doing C++/MFC and VB6 and felt stuck and unhireable. I was in my mod 30s then. I wouldn’t dare tie myself to a stack that even the vendor is saying is being deprecated in my mid 40s.
I’ve also left a job before when the .Net product I was hired for couldn’t find a market and they wanted everyone to switch and do PHP. All 14 developers left within six months. We all knew the danger of working in old tech.
Religion is the way you happen to defend your switch to . NET in every HN thread, even more than I bash C for, and from your story a certain uncertainty regarding what you got on the CV.
Selling services is so much more than tech stacks.
So you have forgotten about the threads that you responded to where I was advocating for native desktop apps over cross platform apps, where I spent years doing C++/MFC,
Like this quote:
But seeing that I like the optionality of working for any of the dozens of companies that have job openings continuously for JavaScript, C#, C, C++, and even Python, I think I’ll stick with those....
You mean it’s hard to keep track, even though you’ve responded to the posts?
But if the post is concerning Java wouldn’t it be kinda of silly to bring up C++, C, Python, and JavaScript/TypeScript?
What I did say that it was foolish from a long term career perspective not to see where the market is going and stick with a platform that even the vendor said is maintenance mode as far as .Net Framework and Windows Forms - or even Windows only development period. If I did that, I would still be writing C++/MFC apps and VB6.
My animus toward Java is more that Oracle is a horrible steward of the platform and before that Sun was.
Just because I responded to all posts doesn't mean I am able to remember everything.
It is also foolish to have senior devs focus on selling themselves as Language X dev, without any other skill to offer.
I would rather have a VB 6 guy on the team that can do proper software architecture design, speaks fluently two European languages across our customer sites and is able weight what really matters across the delivery pipeline, than someone that knows all the cool and latest of .NET Core, without anything else as added value.
So what are the chances that someone who is doing VB6 in 2019 and is talking about he has been maintaining a legacy combination VB6 app that interfaces with C++/ATL DCOM objects is keeping up with the latest advances in architecture, development practices, etc. compared to someone who does a show a history of transistioning as technology changes?
As I said, having experience with modern technology is just “table stakes” to get your foot in the door if you want to stay at least partially hands on.
With the few unsolicited offers I’ve gotten to work for consulting companies just through my network - the travel requirements just won’t work for me right now - I kinda of know the requirements that most consulting companies are looking for.
Few of them are looking to do desktop Windows applications. Yeah some are looking for ways to run legacy Windows applications “in the cloud”, but most are looking for a way to convert them to the web and I haven’t come across any that actually want to start new greenfield desktop applications or for that matter .Net framework applications. Sadly, most aren’t even looking at .Net Core. Hopefully that will change.
Don’t get me wrong, until I chopped everything off of my resume I did before 2008, I did get a few recruiters who were looking for those older technologies, but why would I waste my time gaining experience in older technogies when there is a ridiculous amount of money to be made as a “digital transformation consultant” or by knowing cloud infrastructure and how to architect on top of it (pretty good at it), and the entire Docker ecosystem (learning it)
WebForms is a super legacy technology, to be fair. How many web API are supported today that originated 17 years ago? There are better uses of resources than to give that new life.
That’s fine. But from an employees standpoint who should always be focused on what’s in their own best interest from a career standpoint, there is no way that it could be argued that it is best to stick with those technologies long term.
The chances are that either (the hypothetical) you would either want to leave the company that is still focused on those technologies or the company would leave you long before your career is over. The last thing a person should want is to have on their resume in two years that their experience is any of those technologies.
There are still companies today using Visual Studio 2008 to support legacy ruggedized Windows CE devices. I have five years of experience with them and still get calls to develop for them today. I don’t go near those types of jobs.
From employees stand point they should learn to diversify their skills beyond programming languages, enterprises that just want typing coders outsource their projects.
The only ones onsite have more to offer than programming language knowlege, like domain business, architecture design, foreign languages.
Employees that want to stay employable should focus on being T-shaped ones.
This has already happened. You're simply spreading FUD. Nearly all the major libraries .NET Framework developers have had access to since 2002 are now available as .NET Standard libraries.
.NET Standard is the compatibility[1] you talk about, but seem to know nothing about.
Lovely theory, but in practice it works more like this:
1) write everything in python because its easy and quick to do so.
2) its slow as.
3) abandon software and write it in something else, or, live on with slow ass software and blame python for being slow and rubbish forever more.
re-writing python in c is a hideously painful process, and its proven to be very unsuccessful practically.
Writing new code in c/c++/whatever and exposing a python api is where successful projects like numpy and tensorflow live.
python is very good at what it is, but no one is ever going to go and rewrite your python code in c to make it faster; its just going to be slow forever.
2) yeah, the performance here is good enough so ship it
3) there is no 3
There are very few situations where performance is going to be an issue for you where there is not an existing C module solution that will solve the problem for you. The tired old 'python is slow' trope is getting more and more irrelevant every day. There are other aspects of the language that may make it a mediocre solution to the problem at hand, but out in the real world most people are simply getting the job done with python.
Unless you are careful, the Django ORM will generate a lot more database accesses than needed. I'd almost bet that most of the time the user spends waiting for the app, the app is waiting for the database.
I'd emphasize that for each tasks that's likely to be a performance bottleneck there are, usually, existing high performance extensions: someone has had the same needs before you.
If there are performance issues, rewriting part of a Python application in C is much less likely than refactoring it, without using other languages, to use an existing high performance library.
Application-specific Python extensions are usually intended to allow scripting of the application, with little concern for Python performance (which is the same as doing the same thing without scripting).
New foreign language Python extensions are usually found in new Python libraries, to make existing proven C or C++ libraries available to Python applications or to improve on existing Python libraries.
By using Python they were able to ship, which is why you have heard of Reddit and they were able to grow enough to have a concurrency problem (something Python still sucks at); the number of sites of any significance that started by using Java for page delivery is probably somewhere around 0.
True, but would they be able to ship within the window they could become relevant? Would they be able to add the required features?
You can ship your own clone of Reddit next week, with blazingly fast code, running on two tiny VMs and supporting more load than Reddit, but would it be successful?
Two languages to learn. Two languages to support. Two development environments. Two build tools. Two CI/CD pipelines. Two testing infrastructure. Two sets of code and security reviews.
Except when all developers already know C, which is really what you want, seeing how no one ever rises above their level of C proficiency in any other imperative language.
Hmm? I'm not saying all C programmers are good, or even that people should prefer C for production code. I'm claiming that if you're bad at C programming, you're not going to be not-bad at programming some other "higher" imperative language.
No C programmer has ever been good. It demands an inhuman level of perfection, or formal methods that boil down to a theorem proving language with C window dressing (the mostly-proprietary stuff Rust competes with).
You'll always need more performance so you'll end up rewriting big parts of the codebase in C because you can't afford the servers and/or can't scale anymore. You'll be kicking the can down the road again and again. Also C is hard. At that point you will realise using Python was a stupid idea when you had other options like Go. It has happened to many people.
You'll always need to integrate libraries already written in C and other languages not under your control. So why use a language that goes out of its way to make that difficult?
That's why Sun's "100% Pure Java TM" campaign and negligent support of integrating Java with native code was so misguided.
Software development is a process. You implement your MVP in one language, then measure its performance with real customers, then incrementally rewrite the hotspots and plug in optimized native libraries as necessary. The language ecosystem and culture should support and encourage that (like C#, Python, TCL and Lua do in spades), not fight against it and condemn you as a mongrel infidel if you dare to miscegenate with other languages.
Sun made a grave mistake with their linguistic supremacist "100% Pure Java TM" propaganda campaign: you should rewrite all of your code in Java instead of expecting Sun to provide you with easy seamless interoperability with existing languages and libraries.
So Sun's JNI and applet web browser integration languished while Microsoft integrated COM and CLR and P/Invoke for seamless interoperability with the web browser and other languages like C++ into Java and CLR. And the insipid influence of "100% Pure Java TM" persists even today (have fun using Android NDK).
Sun also had an unholy obsession with code generation, since their attitude was to breed as much "100% Pure Java TM" Code into the world as possible (see AspectJ, JAXB, etc). While C# took a much better approach of supporting code annotation and metadata and reflection and bytecode generation at runtime so you didn't actually have to generate and compile a huge pile of boilerplate source code (see P/Invoke).
>[...] 100% Pure Java, JavaStar, JavaPureCheck, [...] JavaSpin, HotJava, The Network Is The Computer, and JavaStation are trademarks or registered trademarks of Sun Microsystems, Inc. in the U.S. and certain other countries.
Registering purity as your trademark and insisting that all of your users rewrite every bit of their existing legacy code in your pure language, and never use or talk to any other languages ever again, always seemed like separatist linguistic supremacy to me.
Apparently, C#'s P/Invoke is an evil impure cross-language conspiracy to dilute our linguistic purity and sap our precious bodily fluids, breeding caravans of mongrel coders who will swarm across our open borders and steal our jobs. That's why JNI and NDK are only used by unpatriotic second class citizens with divided loyalties, so they don't deserve to be well supported or maintained.
>"Keep Java pure" is the message behind Sun Microsystems' 100% Pure Java initiative which has already won support from 100 developers but will lock out programs such as Visual J++. The move is an attempt on behalf of the Californian firm to maintain integrity of Java code and build awareness.
>Viewers of cable news network MSNBC may recently have seen a commercial for Sun Microsystems (SUNW) in which a man tells a priest that he's been thinking "pure" thoughts. When the beatific man exits the confessional, he passes a queue of anxious programmers--one wearing a Visual Basic shirt--ready to admit their sins.
>The commercial, which touts Sun's "100 percent pure Java" campaign, is not your usual television ad. But Sun has in many ways shown an almost religious determination to spread the gospel of Java to the far reaches of the globe, even sponsoring a worldwide educational tour for programmers with the support of Netscape Communications, IBM, and Novell.
I have personally rewitten a number of expensive inner loops into C to make Python be less slow. It is easy (if you find it hard Go wont be an option for you). I would say the argument against Python is not raw speed but concurrency model. I use gevent for io bouns studf but going multi CPU with data sharing is hard for the engineer and slow for the code compared to Go and goroutines. Subprocesses are ok and sending data over sockets is ok but serialization several times is sucky. Worse than extra memcpy. Also one big msg can block your interpreter.
Before the language becomes a performance bottleneck there is so much stuff to consider that it quickly becomes clear how the choice of language doesn't really make a difference, except in special cases such as embedded systems.
You bash “scripting” like it is something bad. Granted, as a lowly Python programmer for almost 15 years now I’ve mostly seen myself as a guy who takes some text/data from place A and makes sure is rendered/delivered to some other place called B, in some cases with some transformations applied to that piece of text/data, i.e. more or less a “script programmer”. I did try at some point to learn some Lisp, which I had heard was better at moving and working with data in the way I described, but I either lacked the will to learn it or maybe that I wasn’t smart enough to make the transition, so I’m stuck with working on my data with Python.
You understand the the language your platform is written in and the language you as a developer write programs for the platform in are two completely different things?
Because as a developer I am exclusively writing in a language that sits on top of the JVM. I don't ever need to write in the language that the JVM itself written in.
I have the impression that a lot of the mindshare has switched to the Node and Javascript ecosystem, especially the frontend devs, via the Typescript / Angular path, which is a natural path to Java developers due to the comfort given by familiar concepts like static types, classes, etc.
When I used to do Java, I always found that Spring was a much better framework than Java EE, and have used it in most projects I've worked.
Oracle did not take a note from the Microsoft book and is really behaving that an evil corporate overlord.
It's clear at this stage that they bought Sun in order to slowly turn Java proprietary, and charge billions to the companies that are now fully Java-based for the next few decades.
I'm glad I saw the writing on the wall and switched, but the problem is that Java is still being taught a lot at schools, and school programs especially universities are hard to adapt and only change every 4-5 years or so.