Slashdot Mirror
Oracle Begins Aggressively Pursuing Java Licensing Fees (theregister.co.uk)
Java SE is free, but Java SE Suite and various flavors of Java SE Advanced are not, and now Oracle "is massively ramping up audits of Java customers it claims are in breach of its licenses," reports the Register.
Oracle bought Java with Sun Microsystems in 2010 but only now is its License Management Services division chasing down people for payment, we are told by people familiar with the matter. The database giant is understood to have hired 20 individuals globally this year, whose sole job is the pursuit of businesses in breach of their Java licenses... Huge sums of money are at stake, with customers on the hook for multiple tens and hundreds of thousands of dollars.
Slashdot reader rsilvergun writes, "Oracle had previously sued Google for the use of Java in Android but had lost that case. While that case is being appealed, it remains to be seen if the latest push to monetize Java is a response to that loss or part of a broader strategy on Oracle's part." The Register interviewed the head of an independent license management service who says Oracle's even targeting its own partners now.
But after acquiring Sun in 2010, why did Oracle's License Management Services wait a full six years? "It is believed to have taken that long for LMS to devise audit methodologies and to build a detailed knowledge of customers' Java estates on which to proceed."
Slashdot reader rsilvergun writes, "Oracle had previously sued Google for the use of Java in Android but had lost that case. While that case is being appealed, it remains to be seen if the latest push to monetize Java is a response to that loss or part of a broader strategy on Oracle's part." The Register interviewed the head of an independent license management service who says Oracle's even targeting its own partners now.
But after acquiring Sun in 2010, why did Oracle's License Management Services wait a full six years? "It is believed to have taken that long for LMS to devise audit methodologies and to build a detailed knowledge of customers' Java estates on which to proceed."
Larry Ellison is the greediest man on earth and Oracle is his prophet.
Having worked with both Java from Sun and Java from Oracle, there is a vast difference in ideology . It still seems that Oracle does not want to give up that the Database Engine is application and not just a data store. This is the reason I avoid any ADF type work. The database is just that a data store not the application.
I never thought I would be on the same side as them.
Why is Snark Required?
The rats know the Oracle Ship is burning and are trying to milk every last drop from the Java cash cow before they scurry into rafts.
Table-ized A.I.
The industry prefers a strongly typed language for certain mission-critical applications, but the choices are dwindling there. Dynamic languages are just a poor fit for certain applications.
JavaScript is not a viable alternative also because it has an awkward OOP model and/or syntax that forces one to over-use anonymous functions or lamdbas.
Table-ized A.I.
Isn't there an open source version of Java? What's the issue? Who cares what Oracle does if there's code available?
I agree, the question is if this headache may cause Ada to grow stronger. But even though C# isn't as good and strict as Java it's likely the language that will benefit from this.
If builders built buildings the way programmers wrote programs, then the first woodpecker would destroy civilization.
They are only going after companies that explicitly enable pay to use features of the ORACLE JVM. As in you cannot accidentally use these features, they just wont work. Of course any shitty intern can write a script that includes the required EnableCommercialFeatures flag, at which point you fire the intern and switch to the OpenJDK, which is the official reference implementation of Java without the commercial features of the ORACLE JVM.
Perhaps now is the time for all those university courses to abandon Java and start teaching C++1X with best practices as the first language. It's better to open the world to the students rather put them into a cube composed of symmetrically transforming interconnected cubes, with traps, and close the door until one survival walks out.
I honestly don't know. At which point do you need to pay for Java?
Is it you need to buy a licence to write code in Java? Run the code you've written? Distribute your Java code to others?
Specialist Mac support for creative pros, Melbourne
But even though C# isn't as good and strict as Java .....
"Good" is subjective, but how is C# not as "strict" as Java? Is it because C# has a dynamic type? Honestly curious here,
Reading slashdot one-liner: (irm http://rss.slashdot.org/Slashdot/slashdot).rdf.item | fl title,desc*
JavaScript is not a viable alternative also because it has an awkward OOP model and/or syntax that forces one to over-use anonymous functions or lamdbas.
That's the most ridiculous reason why not to use Javascript.
That's like saying Java is a poor fit because it forces you to use curly brackets.
It's particularly stupid given that now that Java has lamdas, I can guarantee they'll appear everywhere. And do you know why they appear everywhere? Because they're really fucking useful.
Javascript has its oddities, but it's maturing very well - ES6 is a very good language. Yes the OO model is different. But ever since the Java Beans pattern came into vogue, Java hasn't really made good use of OO either. Everyone just treats classes as static Hash Maps.
The strongly-typed language argument is utter bullshit too. Yes, it's a class of bugs that is sometimes limited a bit in statically typed languages (but definitely not eliminated), but the contortions you have to go through to compensate for it introduce new ones.
If you're writing tests anyway, you'll still find the bugs before production, and there's plenty of auto-build frameworks that will run unit tests on file save, which means that you're getting the feedback at the same time you would with a static language anyway.
You haven't actually done any Javascript development, have you?
Not really, and not in the last few years....
Javas is not a proprietary language. Most people who use Java never do business with Oracle.
"First they came for the slanderers and i said nothing."
The overall story: Java is dead.
Java will die at a speed limited the by ability of large corporations to move away from using it.
A C bootstrap compiler, a second open source implementation, and auditing of GNAT.
As it stands right now, if you want to run Ada, you probably run a binary bootstrapped copy of GNAT (open or proprietary). Furthermore you are using all the GNAT Ada tools, which may or may not interoperate well with third party implementations. Furthermore, AFAIK two of the current Ada 'standards', aren't standards at all, but proprietary extensions on top of the latest ada release (2012 or something?)
Another helpful feature might be an MIT/BSD licensed core library. AFAIK all the GNAT releases are GPL licensed libraries, unless and until the GNU release, at which time they are still LGPL'd which for many people is a non-starter for app development.
Besides GNAT has anyone used an alternative Ada compiler in the past decade or so that wasn't a legacy implementation?
Disregard the "RE: death moans" comment, I didn't see that this got posted when I was using my phone, so I wrote it again. In case someone wonders why there are two responses making the same point.
Very fucking great. So now, instead of letting the compiler do its job, I also have to write the parse for the compiler myself as an unit test so that when I save the file I get the same result as I would in a fucking IDE with a fucking sane static language with a fucking normal compiler.
I think those scripts that convert Java to C# are going to become very popular!
I have seen them try to claim license fees for trivial things within my own company. It cost them in the long run, since IT abandoned their software in short order, due to this vindictive approach.
The crazy API copyright case made Java a non-starter for any new projects, since they effectively want to contaminate third party code bases with their copyright, if you use any Oracle APIs, making it impossible to port/wrap Oracle designed interfaces. It was something our legal people couldn't countenance, resulting in a Java ban. Not a good way to run your business.
I don't see Oracle having any long term future. Nobody would make a new deployment of any of their products. The Oracle database is still a good product, but for most workloads, open source or commercial alternatives are cheaper/faster. In my opinion Oracle is still a better all round product than nearly all the alternatives. That's not enough any more though. The prohibitive costs, poor support, threats, and contempt for customers are insurmountable barriers. Like Sun, I think Oracle will vanish in the long run.
One example off the top of my head is exceptions. Unless the language has softened in the last few years since I had reason to use it, in Java each method must declare every exception that can hypothetically be thrown if it is called. By extension, no other method can use that method unless it catches or also declares those same exceptions. By contrast, C# implicitly assumes that every method can throw a generic exception and it is valid for exceptions to go uncaught.
Unfortunately, Java code can throw a lot of exceptions implicitly and these need not be declared. Especially class loader exceptions are nasty in this regard as they can pop up at seemingly random and quite unpredictable locations. All you need is some broken or outdated class files in your jar.
Also debugging JS test suite dependency setup code is obnoxious as hell, and constantly necessary if you're using any JS framework with DI/constructor injection.
RISC-V is a better option than POWER and there is substantial and growing support behind it. Good point about ARM by the way; people tend to forget that it is also proprietary since there is a competitive market build around it. However, ARM still maintains control and Softbank will be looking to squeeze more out of it. Open architectures provide a better foundation for innovation, allowing hardware to be composed in ways that are simply not possible today, or greatly complicated by licensing and other IP nonsense. Opening the architecture also enables participation and contributions by educational institutions.
Is at hand.
What's wrong with OpenJDK?
100% agreed. I just don't see how dynamic type advocates think this can just be handwaved away.
So, as the article states, the Java SE downloadable comes with the JDK and JRE which are free to use "for general purpose computing", but the one of the key issues is that additional components such as Java SE Advanced Desktop, Java SE Advanced and Java SE Suite are also included in the same software package, but are not free to use without a license. While there is an EULA, there is nothing to warn users that installing those extra components is not free and there is no form of license checking to prevent user installation without a license. As a result there are many installations where the non-free components have been installed and it is this (in large part) Oracle are chasing money for. While Oracle may be able to point to the EULA, it may be possible this will fail the Reasonable Person test (ie. an average person downloading the package for free, and allowed to install the extra components unopposed, might reasonably believe that all the software in that package is free to use). It seems to be the software equivalent of a bait and switch. I wonder how long it will be before someone challenges Oracle on this tactic.
Most of those issues are ones of taste, not significant barriers. The real problem with JavaScript is that it has a single numerical type, and that type is a stupid choice. You can't do 64-bit integer arithmetic in JavaScript in a remotely sane way.
I am TheRaven on Soylent News
Just don't bother with the debate. Scripting languages are great and useful and all, but people who ONLY write in them are not programmers. They are either sysadmins (a different discipline worthy of respect) or "web developers" (not so much).
However, ARM still maintains control
And if you want to see what happens when they don't, look at what happened to MIPS. Every MIPS vendor implemented their own extensions and you have a choice between portable code and code that runs at a reasonable speed. In contrast, ARM binaries run on any ARM system. RISC-V still hasn't yet designated different parts of their NOP space for trapping and non-trapping NOPs, so extension is going to be difficult, and the RISC-V Foundation still doesn't have a process for introducing extensions for review and standardisation. This is why the ARM ecosystem is so valuable and the MIPS ecosystem is a wasteland.
I am TheRaven on Soylent News
Since the Sun purchase, anyone still using Oracle stuff is just stupid. Even running their DBMS has been crazy for years.
Oracle has been acting like a thug. They pressured their sales people to push "Oracle Cloud" on clients who didn't want it.
Thugs need to be left to play with themselves. Alone.
Anyone ever tried to use any other Oracle product knows they all suck. It is only the formerly-F/LOSS projects that are worth anything and most have been forked.
Remember the OpenOffice debacle? More of the same folks.
RUN! If you don't, you deserve what happens.
It's time for a little uninstaller project. A nice piece of software that will make sure that you only have the free bits installed.
Suppose you were an idiot. And suppose you were a member of congress. But then I repeat myself. -- Mark Twain
Dynamic languages are just a poor fit for certain applications.
That's true. Different languages have different uses. There might be a few places where Java is the best choice - but not many.
I've seen far more projects (mostly database/web stuff) where a dynamic language like Javascript or Python would have been far better choices than Java. But Java programmers often don't know anything else (many can't even write a simple SQL query) so they try to use it on everything.
The problem what Java exceptions is that the caller usually doesn't know what to do with them. Take a look at any large Java program and you'll see it swallowing exceptions all over the place. I'm not saying that's good, just that it happens.
How does the Oracle culture impact VirtualBox. A lot of people like me still use it on our home desktops.
Don't forget to pay your $6,999,999 licensing fee, you cock-smoking teabaggers!
Confucius say, "Find worm in apple - bad. Find half a worm - worse."
Java lives on in the same way x86 lives on...inertia. There's a LOT of software written in Java, a good portion of that is open source. e.g ArgoUML,CompendiumNG, etc Programs that would be hard to move to something else.
There are so many products that make use of ZFS technologies. I wonder if Oracle eventually plans to go after those as well.
The Java [garbage collection] license [garbage collection] [garbage collection] [garbage collection] audit [garbage collection] [garbage collection] routines were
[garbage collection] written in [garbage collection] [garbage collection] [garbage collection] java and [garbage collection] [garbage collection] because of the code [garbage collection] [garbage collection][garbage collection] size the gar [garbage collection] [garbage collection] bage collector [garbage collection] [garbage collection] could [garbage collection] [garbage collection] not keep up.
Java is faster [garbage collection] [garbage collection] [garbage collection][garbage collection] than C [garbage collection] [garbage collection] you [garbage collection] [garbage collection] [garbage collection] just have to [garbage collection] [garbage collection][garbage collection] wait [garbage collection] [garbage collection] [garbage collection] for the JIT and [garbage collection] [garbage collection] GC routines [garbage collection] [garbage collection][garbage collection] to profile [garbage collection] [garbage collection][garbage collection] your [garbage collection] [garbage collection][garbage collection] code.
Oracle does NOT charge for Java or for the JVM. They charge for ancillary, additional products that can be used WITH Java. A lot of companies either didn't pay enough attention to the licenses or thought they could squeek by under the radar. And their getting caught. Complaining about this is like complaining that someone charges money for a Firefox plugin and saying Firefox is dead, yet not saying a thing when someone charges money for a Chrome plugin.
The amount of conflation and trumped-up hysteria around this topic boggles my mind. Look, I hate Oracle AND Microsoft. But use your brains people. Both are gonna try to rope you in with just enough "free" stuff in hopes that you will end up paying for their very-not-free stuff. Get over it. It is part of your job as a programmer to make sure you don't use any products or code you aren't willing to pay for.
It's only a marginal advantage. I've seen plenty of bad Java code that rethrows exceptions from the Java API as RuntimeException (which acts like C# exceptions, in that it can be silently thrown from any method without warning) or has catch (Exception e) {} everywhere to avoid dealing with exceptions "until later".
I know everyone loves to hate on Java and Oracle, but my understanding is that in order to access the licensed features, you have to deliberately add the command line arg "-XX:+UnlockCommercialFeatures". It doesn't seem like rocket science what this might mean...
I've seen far more projects (mostly critical server stuff) where a strongly typed language like Java would have been far better choices than JavaScript. But JavaScript programmers often don't know anything else (many can't even write a simple SQL query) so they try to use it on everything.
Spoken like somebody who has limited real-world experience. Sure, JavaScript is useful in some situations, but is woefully inadequate for other problems. Not every application is a web page slapped on the front of a small database.
Java seems to have been designed with the "everything must be handled" philosophy in mind. That's fine and all, but it's unrealistic, and it leads to empty catch blocks everywhere. That turns into bugs and logic problems that the users report because testing doesn't find them.
C# was designed with the more pragmatic "handle it if you need to" philosophy. This leads to uncaught exceptions, which lead to more developer work prior to release as the devs work through "well, it's throwing a NullReferenceException here" (everyone's favorite...until they encounter TypeLoadException). This leads to actually fixing the source of various problems in the code before even sending it to the testers.
Nothing really, just busy killing Java.
Yes, we're saying the same thing. Pick the right tool for the job.
How about Oracle focus on its' well-deserved greedy reputation, and resolve to actually produce products that have been designed for reliability and verified by competent testers before unleashing bags of bugs on the Internet?
The whole POINT of Java has been: Make the platform open source, and license the developer half of the project: Developers pay for the tool, and right to run on the freely distributed platform.
The whole RESULT of Java has been: Customers have to frequently update "free" Java to "fix bugs," which--in the process--makes prior dependent code unreliable.
The entire idea is founded on a thin layer of fermenting bullshit, and I wish we'd just all abandon it. In fact, all platforms serve a (usually short) useful life, compared to other durable products. If we developed cars like we develop most commercial software, we'd still be driving V8.111 of the original Nash Rambler, with its' monthly required return to the shop for repairs.
Most computing devices sold in the last few years run Android, and are therefore programmed primarily in Java. As a result we now have a whole new generation of programmers raised on Java.
One can certainly make the argument that Java SHOULD die, but half of young programmers are below average and therefore would have difficulty switching to a new language built around a different paradigm. They'll stick to Java.
Oracle begins aggressively trying to Kill Java.
Java is already starting the death phase, and Oracle just wants it to die already by trying to encourage companies to not use it.
Do not look at laser with remaining good eye.
oh man, programming in Java felt like walking in cement shoes. But, programming in perl gave me a big appreciation for rigid programming languages under certain conditions. A big code base, with lots of libraries, some of which do heavy lifting, is a good place for Java. Done with a strict compiler can save lots of time hunting for bugs.
Just don't bother with the debate. Scripting languages are great and useful and all, but people who ONLY write in them are not programmers. They are either sysadmins (a different discipline worthy of respect) or "web developers" (not so much).
Scripting languages are extremely useful and powerful in all manner of data processing tasks which is increasingly spreading into data analysis.
Actually, Sun originally aimed to create an entire ecosystem of a platform from Java. It included modifications to C++ as a language, including virtual machines to solve the issue of cross-platform portability, and even a (short lived) CPU platform that would have used bytecode as the instruction set.
The reason most of the users went to PC/Linux platforms was that you had Linux that was a common factor to both x86 and SPARC, and you not only had lower prices for the former, but it also had a wide range of price points compared to SPARC.
Half of all programmers are below average. It's a statistical tautology and meaningless. How does it follow that being less than average at being a professional programmer would make them incapable of being less than average at another programming language?
How does the Oracle culture impact VirtualBox. A lot of people like me still use it on our home desktops.
There are two variations of Oracle VirtualBox, the open source / free software edition and the enhanced features edition. That is unless Oracle has merged these into a single product. You can download the software source code for VirtualBox any time if you are worried Oracle might remove it from publicly accessible website.
RISC-V still hasn't yet designated different parts of their NOP space for trapping and non-trapping NOPs, so extension is going to be difficult, and the RISC-V Foundation still doesn't have a process for introducing extensions for review and standardisation. This is why the ARM ecosystem is so valuable and the MIPS ecosystem is a wasteland.
I remember ARM's earlier work, which had the very same difficulties you describe for MIPS architectures. Every implementer had a separate memory protection/paging architecture, every one had a different interrupt routing architecture. What a grinding mess that was... They wised up *just in time* (IMHO), establishing core ("Cortex") functionality which is required for all implementers. That stabilized the ARM ecosystem enough to allow it to grow dramatically.
If the implementers of RISC-V are wise, they would establish and agree on functional (powerful, effective) support structures such that it's possible for developers to implement kernels and OSes around it.
Given Softbank's purchase of ARM, I am watching their actions very closely. All of the embedded devices used in my company and many others are Cortex-M3, -M4F, and the many -A series processors. Softbank is in a position to increase their IP licensing fees for immediate profit, screw over the entire embedded marketplace, and would end up, after much consternation in the embedded world, ceding the market to competitive low-end X86 and one of the lesser-known architectures (MIPS: Microchip's choice for PIC32. Irony... :-) ). This is a good place to mention RISC-V *if* they are smart about portability.
How bad will anyone feel when they go belly up like SCO.
https://www.youtube.com/c/BrendaEM
Half of all programmers are below average. It's a statistical tautology and meaningless.
Not quite meaningless, it implies that the average as the same as the mean. BTW, isn't "meaningless tautology" a superfluous redundancy?
When all you have is a hammer, every problem starts to look like a thumb.
While you raise an interesting point, it is a bit ironic considering what a disaster the ARM platform is, if you can even call it that. ARM binaries may be portable, but virtually every ARM system requires a custom OS build. No doubt, there is work to be done on standardizing the RISC-V platform and ensuring that extensions play nicely, but that is under way.
The standardization process doesn't need a corporation to enforce it with intellectual property, and the ARM model smothers innovation. At any rate, those who desire to should be free to go their own way, as with the BSD licensing model. Few will extend the architecture in non-standard ways, because of the trouble that entails in the toolchain. Most uses will just be composing various SoCs and embedded controllers with standard cores, only without the trouble and expense of licensing.
The real problem with JavaScript is that it has a single numerical type, and that type is a stupid choice. You can't do 64-bit integer arithmetic in JavaScript in a remotely sane way.
It seemed to make sense at the time, when Livescript was just a quick hack for simple dynamic web glue. But the fact that this gaping wound made it through multiple upgrade and standardization cycles has to be a major embarrassment for all concerned.
When all you have is a hammer, every problem starts to look like a thumb.
Let me be a bit more explicit, since you had trouble understanding the more diplomatic language:
There are 3 million Java programmers who aren't that bright. They won't be able to easily switch to a completely different way of doing things.
Speaking of the fact that many people aren't that bright and have trouble understanding new things ...
"Microsoft is not one bit more trustworthy than Oracle."
From a Network World article: Windows 10 is possibly the worst spyware ever made. Quote: "Buried in the service agreement is permission to poke through everything on your PC."
BTW, isn't "meaningless tautology" a superfluous redundancy?
Well played, sir.
Starships were meant to fly, Hands up and touch the sky - Nicky Minaj
This just makes you wonder if their strategy is to make people who have used Java quit using it and use or create another platform. I think they need to think long and hard about their position here. It is entirely possible that they will end up suing their way right out of business. There have been other companies that decided to go with the sue everybody that uses it strategy and ended up going broke.
I have to disagree. Almost every use-case I've seen for them is because either the language, including Java, also has a poor OOP model (which you seem to agree to later), or the API is poorly designed.
For example, why can't one add an OnClick method *directly* to a button object? Why go through the Listener middle-man thingy? That's silly. 98% of the time a GUI implementer shouldn't have to give a damn about a Listener engine; that should mostly be hidden guts.
I kind of agree. I wish languages were better designed to be strong/static, and dynamic where needed instead of all or nothing. Root API's are usually best as strong/static typing, but the outer layers usually best as dynamic. It would be nice to declare some modules as strict and others dynamic.
Table-ized A.I.
Javas is not a proprietary language.
That will be decided when Oracle v. Google is appealed.
but half of young programmers are below average
And most older ones are, hence the reason software these days is more stable than it used to be. But by all means continue blaming all your failures on millennials.
That's a very concise way to refute your points. Your appear to be indicating that:
a) Millennials are highly competent, at least at at programming / mathematical type tasks.
b) You take personal offense at anything you perceive as a criticism of "millennials".
c) Half of younger people, and most older peopler (more than half of all people) are below average.
Points (a) and (b) strongly suggest that you *are* a millennial, point (c) demonstrates you are incapable of understanding fourth grade arithmetic.
So what is your definition of a programmer then?
No, you are wrong. Oracle v Google has nothing to do with whether Java is a proprietary language, because it is not addressing whether languages are copyrightable (only the APIs).
And if you're thinking that the APIs are a critical part of the language and thus should be included in your sloppilly worded sentence, then you're still wrong: Java is licensed under the GPL, and Google's problem is entirely that they didn't release their implementation under the GPL (which they've changed now, and thus will continue to use Java freely even if they lose the lawsuit).
"First they came for the slanderers and i said nothing."
Java has been dead for years, it is slow, clunky, always needs an update, updates break everything, insecure, etc. I hope this will finally get programmers to stop using it. Bye Bye Java YES!
Just in time to pump up the awesome C++17.
It's especially annoying as there are idioms that will force all major JavaScript implementations to treat a value as a 32-bit integer, yet none that will work properly for 64-bit arithmetic, because the standard explicitly prohibits providing more than IEEE 64-bit floating point precision. It's even more annoying when you use the TypedArray types, where you can load and store 32-bit floats, 64-bit floats, 8-, 16-, and 32-bit (signed and unsigned) integers, but you can't even store 64-bit values - you have to treat them as a pair of 32-bit integers and perform your calculations as if you were dealing with a bignum.
The depressing thing is that Smalltalk solved this for dynamic languages sensibly in the '70s. Smalltalk had SmallInt objects that were embedded in pointers and were transparently promoted to BigInt objects on overflow. It also has a family of Float classes that implement fixed-precision floating point values (either the IEEE standard sizes or user-defined sizes if you'd prefer to trade speed for more precision).
I am TheRaven on Soylent News
virtually every ARM system requires a custom OS build.
That's not really true. With FDT (or ACPI in ARMv8), kernels can auto-configure. It's only older (pre-ARMv7) systems that need a lot of system configuration. We have had working generic ARM kernels for FreeBSD for a while now.
Few will extend the architecture in non-standard ways, because of the trouble that entails in the toolchain
This is exactly what happened with MIPS. People extended it and provided their own GCC version. The GCC changes were never upstreamed because, in most cases, they broke other MIPS targets. The vendors didn't maintain them, so you're always stuck with some vendor's old GCC version and all of the bugs that it brings. ARM managed to avoid this, encouraging people to move the innovation to other cores on the SoC.
I am TheRaven on Soylent News
For every engineer hired, also hire 2 lawyers
Scripting languages are programming languages. They just target other software instead of the system interface.
Because having a final else clause for the unexpected ones is better?
I suppose that depends on what the final else case does. If it ignores them, it's much worse, if it raises them, it's the same. No better in any case.
John McAfee 'It was like that time I hired that Bangkok prostitute; to do my taxes, while I fucked my accountant'
Welcome Open Source world to...Microsoft and .NET.
If the golden goose isn't laying enough eggs, threaten it with a carving knife - and shakedown our customers while you're at it. --Uncle Larry
If the idea is to charge licensing and support fees they will probably kill Java. To me its great I never liked Java.
ORACLE = One Real Asshole Called Larry Ellison
Do i have to pay for that too?
The strongly-typed language argument is utter bullshit too. Yes, it's a class of bugs that is sometimes limited a bit in statically typed languages (but definitely not eliminated), but the contortions you have to go through to compensate for it introduce new ones.
It's not utter bullshit. Hardware languages have moved in the direction of strongly typed for years. VHDL is like Ada, and SystemVerilog is a strongly typed version of Verilog.
These days I do Ruby, Java, VHDL, and SystemVerilog. I enjoy programming in Ruby - it's a wonderful language - but I have to admit that there are times using languages with static checking capabilities makes a lot of sense. I've seen potentially very expensive bugs caught by static checking. Strong types are the first step in supporting static checking.
Industry experience has shown that static checking is extremely important when designing systems that have to work right with a small number of iterations. In hardware systems, for example, making mistakes can be very expensive, and having to do multiple spins of an ASIC is not a good thing. A mask set in a modern process can cost millions of dollars - and the lost engineering time can dwarf that, and the lost revenues can dwarf the engineering time!
Of course, in that business, people are used to relying on static checking tools such as lint and formal verification - so it's not a huge step to move to languages with better support for static checking. It's a very different world from that occupied by the script-kiddies.
Strong types also make it a lot easier to document libraries. I see that benefit every time I program in Java - the libraries are FAR easier to understand than similar libraries in Ruby, or a lot of stuff in the Microsoft World (such as that horrible Visual Basic language).
There is a net gain for having the option to do static checking in a programming language. It would make a lot of sense for every mainstream language to support this - even if the language designer gives the user the option to turn it off (or has it turned off by default).
Having said that, I can appreciate the desire of people to not end up in "template hell". C++ can be a monster - but since it's also a dinosaur that's not surprising.
Unfortunately, Java is Enterprise and used in large Enterprise business servers such as SAP, Databases, etc. So Java is not going anywhere. C# is for the client side, and the big money is in enterprise servers, not client side. Enterprise is the reason Java is slow at adapting new functionality, because in Enterprise you have very long support cycles (decades) and you dont want to break compatibility. Sun said that Java must evolve slow because Sun was targeting Enterprise servers, but the Java libraries would evolve fast. So all Java evolution would occur in the libraries, said Sun. Oracle has inherited the thinking, being enterprise server company.
.
OTOH, C# is a client side language so it can evolve fast, with short support cycles. You can shut down the desktop PC and upgrade and reboot without affecting thousands of users. That is the reason C# adds all the fancy functionality without hesitation. Microsoft is not targeting enterprise servers, but desktops. So Microsoft does not understand the enterprise market, and evolve C# fast.
.
Another large reason Java is not going anywhere, is because Java is very very fast. All fast stock exchanges with extreme throughput and ultra low latency (sub 100 microseconds) use Java or C++. Adaptive compilers that Java has, can in theory be faster than static compiling C++. Because C++ will compile to the lowest common denominator (can not use SSE vector instructions), but Java will recompile in flight optimizing to your specific hardware (maybe activating SSE vector instructions). Another example why adaptive compilers are faster: say you want to run a for loop on a million HourlyEmployee objects, this means Java will optimize that run for HourlyEmployee objects. The next second you want to run the same for loop on a million MonthlyEmployee objects, this means Java will optimize on the fly for a different kind of objects. C++ can not do this, optimize differently depending on different objects. C# is way way slower than Java, and if you need the highest performance, you need to go to Java.
.
Also, the worlds fastest cpu is 32-core SPARC M7, there is no contest. M7 is 2-3x faster than IBM POWER8 or the fastest Intel Xeons (all the way up to 11x faster). Even the next IBM POWER9 will be slower than M7. Here are 30ish world records for M7 (SPARC S7 is a crippled M7 with 8-cores):
https://blogs.oracle.com/BestPerf/entry/20161206_ycsb_s7_2l_cassandra
.
This means the fastest business servers (they all run Java) will be SPARC M7 servers. So if you have extreme performance demands for business software such as SAP or databases, you need to go to large Oracle 16-socket SPARC M7 servers. There is no other choice. You can not use C#. Oracle knows you have no other choice for extreme business workloads, and can therefore claim money from every large Enterprise company and the companies can therefore not leave Oracle's grip.
It is Oracle's right to defend themself against copyright violation. Nothing wrong about this. I have been a proud shardholder of Oracle for around 5 years and have to say I'm really happy with the high yield of their stock's interest. Java is copyright by Oracle Corp. it's illegal to steal software. You ought to know what you are doing and understand the license carefully.