That just means it won't be AOT compiled. The JVM can still JIT them.
> No decrease to JVM start up times
The JVM itself starts quite fast. Most of the time spent in startup comes from the applications themselves. Spend a lot of time in the interpreter running their startup code and burning CPU cycles on the lower compiler tiers.
> The only supported module is java.base
Supported in the sense of oracle offering support. You can still compile other modules. It's just experimental.
Jar unpacking can contribute quite a bit to startup times. It would be neat if this also did a pre-linked library as well.
edit: I should add that this really only matters for large numbers and sizes of jars.
My question is how much memory can be saved by not having the JIT. Sure you still have a GC with a heap (VM) but one of the big pigs in memory can be the JIT.
I would have hoped to see it sub 5MB.
If 24-48MB is trivial completely depends on what is stored in this space, i.e. is there a more efficient representation for your stated goals? Context is king. Even 5MB could be non-trivial, depending on context.
There are quite a few manufacturers that have been replacing their firmware with such versions of Java.
$ java -version
openjdk version "1.8.0_91"
OpenJDK Runtime Environment (build 1.8.0_91-8u91-b14-0ubuntu4~14.04-b14)
OpenJDK 64-Bit Server VM (build 25.91-b14, mixed mode)
$ java -Xmx999k
Error occurred during initialization of VM
Too small initial heapIf you don't know better I can gladly provide you some links to embedded Java vendors.
I welcome concrete counterexamples of why this expectation would be realistic.
http://www.ptc.com/developer-tools/perc
JamaicaVM requires 1 MB
https://www.aicas.com/cms/en/JamaicaVM
MicroEJ can target Cortex-M processors with 128 KB flash and 32 KB RAM.
http://www.microej.com/products/device-software-development/...
Oracle's offerings, Java ME Embedded reference implementation requires 128 KB RAM and 1 MB ROM
http://www.oracle.com/technetwork/java/embedded/javame/index...
Java ME might not seem relevant in 2016, but it is running on the majority of Ricoh copiers
https://www.ricoh.com/esa/features.html#01
And smart devices produced by Gemalto like Cinterion, EHS6 digital phone or smart meters.
http://www.gemalto.com/m2m/development/innovation-technology...
http://www.gemalto.com/m2m/solutions/modules-terminals/indus...
Cisco phones,
http://www.cisco.com/c/en/us/products/collateral/collaborati...
And many other embedded manufactures, that are jumping into IoT.
On embedded systems it might not be trivial, but on my laptop with its 4gigs of RAM and even more so on my desktop with 16gigs, 50mbs is definitely trivial.
Do you know what you are talking about ? Android is totally different thing than JVM and Java Ecosystem ! It is totally different technology ! They use one step to turn your bytecode to their own dex file, after that it is completely separated from Java ecosystem (Java as ecosystem which comes from Oracle).
I am fascinated on HN, how comment uneducated like this, haven't got down voted.
They use kind of hybrid AOT/JIT right now. (It was interpreter until 2.2, they switched to JIT, in android 5 they switched to complete AOT, now they are going kinda hybrid approach).
Also risk of "hot pathing" the wrong paths if the server comes up during say a market closed time...
Exactly. There are a lot of high performance system written in Java. For long running systems, the startup cost is irrelevant. And for networked systems (such as fintech) you are going to be IO bound. The main issue as far as Java and high performance is the GC related pauses and that is a concern shared with any GC'd runtime.
I am not aware of any trading company using it. May be some.. but the high perf people I know go other ways.
[1] https://lmax-exchange.github.io/disruptor/ [2] http://martinfowler.com/articles/lmax.html
If you had an IF somewhere random in your code.. you will then JIT code that is wrongly optimized.
If you try to put some kind of network device to capture the traffic and respond with fake responses to make the code happy.. you are one bitflip away from sending bad stuff to prod.
Including some ascii art of Trogdor the Burnanator!
My question is really "why will it succeed this time?" Did GCJ and similar technologies not take off because Sun didn't support them? Or because it is a really neat technical challenge that solves a problem people don't actually care about?
So, yes, this is cool. But, I'm currently giving it a likelihood of success really low, since I have priors that failed. What other evidence are people seeing that make this something to be excited about, as opposed to just impressed. (Or, are we just impressed and I can go back to my corner?)
Sun was religious against it.
Regarding the GCJ, it failed because it is a hard problem where people didn't work for free and most of them stopped working on it when the OpenJDK was released.
While others read newspapers on the train, I read papers. :)
In any case, these provide AOT.
JamaicaVM, PTC Perc (former Atego and Aonix), IBM J9, Oracle Embedded Java, OS/400 Java (uses the same bytecode deployment as the other OS/400 languages), Excelsior JET, and probably a few others in embedded market that I am not aware of.
And of course the Android Java fork with ART.
* Only 64bit Linux on AMD64 is supported, so no ARM or Android support currently.
* Files must be ran on computers they were compiled on, or identical hardware
* Still needs GC, only G1 and Parallel GC are supported
* No dynamic byte code (Lambda Expressions, Dynamic Classes, etc.)
* The only supported module is java.base
* No decrease to JVM start up times
* Still need the JVM
* Some decrease to spin up as there will be less JIT passes that require stopping the world.
Effectively this just lets you pre-load .class files into the codecache directly rather then running the ~10k initial byte-code passes before they'd receive a JIT pass and that would happen.
Lastly .so is just used as a container so I doubt we can expect to dynamically link against AOT compiled Java in C/C++/Rust land.