It's not just Java 1.7, it's still there in Java 6. I'm not sure about 7 or 8, but that's a hell of Java apps that break because of the Java dev's shitty code.
How badly coded are Java applications?
There, fixed that for you.
Seriously, it's Java apps and other poorly coded apps, and I'd wager all of them break because the code says "if os.name startswith("Windows 9") throw RuntimeException". It looks like all versions of OpenJDK have this as their version check before running. And there's no way for Oracle to fix it, because the problem is in each individual Java app written using OpenJDK. Which, of course, means MS can't fix it either. They normally just slap an exception on this kind of bullshit and move on, but it won't work this time. And really, I'm not even sure there is an incentive for Oracle to fix it anyway. They aren't the ones who will be losing sales because of their fuckup.
Way to go Java!
Link to Original Source
Someone at MS is just pulling this out of their asses to try and cover that Microsoft has no clue what they are doing.
So they were able to easily query the code for a few thousand applications online that made this version check mistake. Big deal.
Pay attention. It's not a few applications. It's all Java apps. All of them. Anything written using OpenJDK is going to fail, because it checks the runtime version and throws an inappropriate error. Hell, if the JVM uses the same libraries as the JDK, those aren't even going to run. That's not a few thousand apps online, that's millions of apps, online and off, professional and amateur.
So the Java devs wrote shitty code, and it's Microsoft's fault? Nice. What a fucked up way of looking at things. It's clear you hate Microsoft for some obscure, personal, bullshit reason, but that's a huge stretch. All the Java guys had to do was look for "Windows" and the actual version number instead of "Windows 9" and there is no problem. But no, they had to be dumbfucks about it. It's not even easier than the better alternative - it takes MORE code to write it the shitty way instead of thinking for a whole minute and coming up with a better solution.
I imagine what actually happened at Redmond was something like this: MS dev starts installing applications, testing compatibility, and starts seeing messages like this "This program is not compatible with Windows 9x". Oh shit. Test some more apps, and "Runtime error - wrong OS version, please use Windows XP or later". MS dev can only sit there and say "Oh fuck". Turns out thousands of shitty programmers everywhere used the dumbest possible version discovery method (that they almost certainly didn't even need in the first place) and the only fix for all of these programs is a fix in their own code.
I'm not sure if you're getting this or not. Java apps built on OpenJDK will put a runtime error on Windows 9. All of them. Microsoft didn't write that code, Sun did (at least I'm pretty sure they did). Microsoft has had API's for accurately getting the version number since Windows has been a thing, and Java doesn't make them available.
I honestly can't think of a way for Microsoft to work around Java's shitty libraries, or any other program parsing the OS version from text in this stupid way, in any way except to rename the OS.
Compare this to how many applications out that that have broken because of other minor OS changes combined with bad programming. I've seen piles of that myself, and Microsoft never bothered this hard to keep compatibility for any of those.
Really? MS is the only OS that does care about compatibility!
Microsoft has always bent over backwards for compatibility. That's the one thing that sets them apart from OSX and Linux, and why businesses love Windows so much. We're running a critical Windows 98 application on Windows 7 right now, with no compatibility issues whatsoever (not even compatibility mode). Try updating OSX and after two or three revisions shit starts breaking, because Apple doesn't give a shit about backwards compatibility. Not so with Windows.
Plus, with every Windows release, a software maker can get a beta version of the OS and test their software on it. If their software is intrinsically broken, all they have to do is contact MS, tell them what's up, and MS will put in a workaround. Even if that workaround only works for that specific software, they'll do it. The most famous example of that was SimCity 2000, which had code written in I think XP specifically for it.
This isn't like when programmers rely on a bug in an API to perform their tasks. MS can get around that by spoofing the bug, and they do it all the time. No, there is no way for Windows to know that Java is throwing a runtime error based on shitty logic, so MS can't fix that problem. In a perfect world, MS could say "fuck em, it's their bug, they need to fix it" and release Windows 9. Java apps wouldn't work, Oracle would release patched versions of OpenJDK (they'd have to do it for ALL versions that were released), and Java programmers would fix their damn apps using the patched versions of OpenJDK.
Unfortunately, there is no way that is going to happen. And who is going to lose millions of sales because, through no fault of their own, Java doesn't work on Windows 9? That's right, Microsoft is. It's possible Oracle could patch the JVM to catch that code, but you can bet your ass Java programmers aren't the only ones who have been this retarded. So the only real solution is to avoid the problem altogether, and skip version 9.
OpenJDK does it exactly like this. Instead of looking for os.name "Windows" and os.version 5.0 and throwing an error for everything else, it actually explicitly looks for "Windows 9" or "Windows ME" and throws an error if it finds them.
So OpenJDK (and plenty of other apps like it) doesn't think it can run on Windows 9 because OpenJDK developers suck at coding, and Microsoft has to deal with it.
Maybe Microsoft should just go with the internal version number: it will cause as much marketing confusion as Windows 10, avoid the "Windows 9" checks, and make the internal/marketing names more consistent.
This is not any fault of Microsoft's. The first result is from a fork of OpenJDK 6, which was released just 3 years ago, when "Windows 7" was a thing, and other results indicate this bad code has been in OpenJDK since at least version 1.7, which would be around '06-'07. God only knows how much other software out there does it this poorly.
These aren't legacy Microsoft apps that are having issues, these are modern, popular third party apps that have been coded very poorly, and Microsoft gets to deal with it. I imagine MS devs started installing third party apps to test compatibility, started seeing results like "Windows 9x is not supported", and just said "Oh shit!"
Seriously, how is Microsoft supposed to detect and work around that behavior? It's software correctly calling MS API's and then doing utterly retarded things with them.
If you'd actually look at the example provided, this is generally modern applications looking for Windows 9x versions in order to throw an error, and they did it in a time when "Windows 7" and "Windows 8" are actual things that really exist, not a nebulous time where MS was changing its naming format every couple releases.
The very first example is a fork of OpenJDK 6, and it appears to be code carried over from the original, not new code. Another result was from OpenJDK 1.7, so this is more than likely poorly written code that has simply never been a problem before.
People would probably blame Microsoft if all Java apps broke on Windows 9, even though it was Java's shitty programmers that did the deed, and really lots of programmers do stupid stuff like this and would blame MS for it. Unlike most bugs, MS doesn't really have any option but to change its name to fix this for software developers. It's not like a dev relying on the buggy behavior of an API that MS can work around for them. This is wide scale, pervasive shitty programming in third party programs that spans more than a decade, and Microsoft gets to deal with it.
Can't be, since Java programs have plenty of access to harm your computer.
The stated purpose of Java (actually, one of 5) was platform independence - write once, run everywhere code that you can run on Windows, Linux, Mac, or any other spinoff that has a JVM. Java makes the independent VMs for each OS, so that programmers don't have to rewrite their software to run on multiple OS's. Any sandboxing for security came later. Sandboxing wasn't a specific goal, though one of the goals was that the language be robust and secure, as any language should be. There is no mention of protecting the system from malicious code, and really even running in a VM Java has way too much access to the system to do that.
What's scary is some of these issues are in the JDK libraries, or at least appear to be. First one on the list is an OpenJDK fork, but it looks like this exact same code shows up in earlier versions of OpenJDK. It's more reasonable that a JDK might need to look at the OS version than Joe Schmoe's Java app, but really even then it shouldn't need to. And even if you really, really, super duper need to know the OS version, what's wrong with something like "if os.name startswith("Windows") && os.version 5 then throw new RuntimeException"? That catches everything earlier than XP, which is obviously what they want, and is far less likely to run into problems with a later version of Windows. A lot of other Java devs did it that way (though some still did a search for "Windows 9" instead of just "Windows"), which you can find by searching for ("Windows 9").
Obviously that last one is supposed to be MINOR.
Hopefully he didn't actually copy this from an MSDN article.
I thought the whole point of Java was that it was supposed to be platform independent.
Why the hell should a Java developer ever need to find the OS name and version? I can understand needing certain features to run properly, but who cares if it's Linux or OSX or Windows that has the feature you need? They should only need the Java version, and the feature available. If the same OS feature exposed by Java works differently on different platforms, that's a major failure of Java's.
If you're writing Java software that is only intended to work in Windows, you're using the wrong language.
(Please note that, although this is only my personal opinion, if you disagree you're wrong.)
It's 3 year old Java code that's the problem, not any Windows code.
If 3 years ago doesn't count as "today's developers", well, you're setting the bar pretty insanely high for replacing code.
It's how Java exposes the OS name to its users. If you look in that list, that os.name property is a native Java function. The Java library itself probably goes through all the BS required to get that, instead of the version number or some other more reliable method to see if your stuff will run.
These days, Arab countries and Muslim culture are anti-science, but for a large part of Christianity's existence, they often had better medicine, mathematics...
There, fixed that for you.
Just because something was good in the past, doesn't mean it's still good now. Except for a few small pockets of enlightenment, the majority of the Muslim world is so anti-science it's shocking just how progressive their cultures used to be.
There are reasons for this (relating to something akin to the Catholic/Protestant divide in Christianity) but yeah, they're pretty much backasswords these days.
Clear proof that the church wasn't interested in the truth, since the pope was, in fact, a blockhead.
One recent documentary I watched, can't remember the name, gave a good deal of evidence that Neanderthals were at least as smart as humans, and gave a similar theory for why humans "won", but for an entirely different reason.
Their theory was based on the attachment point for the trachea to the skull. In Neanderthals the shape was such that it would have forced the larynx to be a particular shape or position which would have precluded the level of vocal agility we enjoy, and therefore the complex verbal communication we developed. Thus, cultural adaptations and communal knowledge spread much slower for Neanderthals than humans.
The communication theory makes a lot of sense to me, considering the fact that there is a lot of evidence suggesting Neanderthals were bigger, stronger, and just as smart as modern humans. Less effective communication is just the sort of thing that could really muck things up for the Neanderthals, and allow us to "win".