Talk:Java virtual machine

Bytecode verifier?!

For what reason it is taken out of the JVM architecture context: The class File Format -> Verification of class Files -> Verification by Type Inference -> Bytecode Verifier?

It's a very bad approach that creates only confusion.--Michelle Ridomi (talk) 19:19, 23 October 2014 (UTC)

Still, the JVM has a bytecode verifier. Do you mean that it's a bad approach in the implementation, or a bad approach in the article? To me it seems bytecode verification has a place in the article. Martijn Hoekstra (talk) 16:38, 28 October 2014 (UTC)

• • No one denies the bytecode verifier existence. Pay attention to the place of the verifier in the JVM architecture. Bad approach in the article.--Michelle Ridomi (talk) 17:24, 28 October 2014 (UTC)
    • Oh, ok. This article is in pretty bad shape, I fully agree. Is there anything I can do to help you make it better? Martijn Hoekstra (talk) 18:40, 28 October 2014 (UTC)
      • I'll take care of improving class loader. The Licensing section shall be rewritten; makes no sense as is.--Michelle Ridomi (talk) 19:32, 28 October 2014 (UTC)

Hi, I see that the verifier section is now gone (i am referring to the content at https://en.wikipedia.org/w/index.php?title=Java_virtual_machine&oldid=631130134#Bytecode_verifier ). I found it much more useful than the replacement text ("ensures the correctness of the imported type"), and i don't understand why it was removed. It contained much useful information that is now gone, such as the philosophy behind verification, an introductory explanation of what kinds of things are being verified and why, and the connection to efficient execution on a register architecture. Any objections if i put it back? Bayle Shanks (talk) 08:03, 24 January 2015 (UTC)

Google Web Toolkit

I've removed

or into another intermediate language (for example, Google Web Toolkit compiles Java source code into JavaScript)

because finding it misplaced. The JVM has no use of Google Web Toolkit.--65.220.39.77 (talk) 12:24, 20 January 2015 (UTC)

JRE def.

Can't we get the actual name, Java Runtime Environment (abbreviation JRE) back into this article? --Mortense (talk) 18:14, 29 January 2015 (UTC)

I just put it back in to the lede (completely unreferenced. I shouldn't do that). Since JRE is a redirect here, I think there either should be more, or the JRE needs its own article. Maybe refocussing this article to be about the JRE and moving it to JRE is the best option. Ideas? Martijn Hoekstra (talk) 18:44, 29 January 2015 (UTC)

Currently the article suggest that any combination of a JVM and standard libraries would form a JRE. However JRE is a trademark from Oracle (see http://docs.oracle.com/javase/7/docs/) I think this should be clearer from the article. --Pdevaere (talk) 10:46, 5 March 2015 (UTC)

This better? Feel free to make any edits that you think improve the article. Martijn Hoekstra (talk) 13:28, 5 March 2015 (UTC)

Yeps, thanks! I'll be bold next time. I'm not sure about wether the JCL is an implementation or a specification. In fact, I can't seem to find any info on the term JCL on the oracle website. And googling it pretty much only finds the wikipedia hits. But I guess that's a discussion for on the Java Class Library page. I'll come back to edit when I'm more certain. Pdevaere (talk) 06:31, 6 March 2015 (UTC)

Undoing revision 653853606 (Intro: Reword phrase that uses questionable terms.)

Java_virtual_machine&curid=16389&diff=653853606&oldid=653330672

• Before: A JVM implementation i a computer program that implements requirements of the JVM specification in a compliant and preferably performant manner
• After: A JVM implementation is a computer program that meets the requirements of the JVM specification in a competent manner.

I want to point out that 1) both terms are not questionable and are used in this context, as the following headlines ilustrate

• Implementation of Requirements under the Food Quality Protection Act (FQPA)
• Making healthcare content easier to share in a HIPAA Compliant Manner
• Walking the regulation tightrope in a socially and ethically compliant manner

and 2) the replacement of compliant with competent is a nonsense. I do not strictly object to the first change (implement/meet) and therefore I will reapply it. — Preceding unsigned comment added by TvojaStara (talk • contribs) 18:44, 31 March 2015 (UTC)

Joint Runtime Extension

JRE can also be an abbreviation for Joint Runtime Extension, aswell as Java Runtime Environment. However, currently JRE links directly to this wiki article. See main JREAP wiki article. 66.155.23.67 (talk) 08:01, 16 July 2015 (UTC)

Page messed up by vandalism?

There seems to be an issue with this specific page. The pages' contents are gone, replaced by a yellow background and red text reading: "ATTENTION WIKIPEDIA READERS: I have evidence that suggests @BoulderTodd was responsible for the death of JonBenet Ramsey. Don't let this wicked man to get away with his wretched deeds!" — Preceding unsigned comment added by YoruFeisu (talk • contribs) 18:34, 16 September 2017 (UTC)

64-bit

Regarding this edit and subsequent reversion made by User:Comp.arch, I still don't see how it's relevant. There is no such thing as "64-bit Java". Java bytecode only understands 32-bit words, with longs and doubles being handled as double-words. That's what JVMs must interpret and execute. They can do so on any hardware they want, but it doesn't change the fact that the Java bytecode is still using 32-bit words.

If you could write a JVM for the PDP-10, you would not have "36-bit Java". You would have a JVM that runs 32-bit Java bytecode on a 36-bit machine.

It doesn't matter that the heap can be larger when you run on a 64-bit machine; the JVM doesn't require any particular implementation of the heap and references, so this is just an artifact of using different techniques to implement the heap and references in JVM implementations for 64-bit platforms. I'm certain it's possible to use techniques on 32-bit platforms to get a heap larger than 4GB, but it would just be unusably slow because it wouldn't all fit in RAM, so nobody has bothered to do it.

The quoted source even clearly explains all of this. "You can think of this environment as being just another platform to which we've ported the SDK." Exactly my point. And they are equally clear that the Java bytecode is unchanged. "We did not increase the size of Java integers from 32 to 64... Array indexes, which are defined in the Java Virtual Machine Specification, are not widened from 32 to 64."

This text just amounts to saying "You can also implement a JVM on a 64-bit platform, but it changes nothing about Java bytecode or the JVM's capabilities." Not interesting, not informative, and also not relevant in an article that's describing the characteristics of abstract JVMs rather than characteristics of JVM implementations. I maintain that this text is unnecessary and should be removed. --Bigpeteb (talk) 16:07, 4 April 2018 (UTC)

You say the text amounts to 64-bit data model "changes nothing about [..] the JVM's capabilities." I believe you're simply wrong there, as 64-bit addressing, means virtually unlimited heap size (only limited by RAM (or virtual memory, RAM+swap)). This is the most common reason people want and go for 64-bit CPUs. Saying the "64 bit data model" is "misleading" and dropping sourced information, as it's "misleading" is a WP:NPOV-violation, when I can also say NOT having the information is misleading". Unlimited heap size vs. much lower down to 1.4 GB:

"The maximum theoretical heap limit for the 32-bit JVM is 4G. Due to various additional constraints such as available swap, kernel address space usage, memory fragmentation, and VM overhead, in practice the limit can be much lower. On most modern 32-bit Windows systems the maximum heap size will range from 1.4G to 1.6G. On 32-bit Solaris kernels the address space is limited to 2G."

"I'm certain it's possible to use techniques on 32-bit platforms to get a heap larger than 4GB, but it would just be unusably slow because it wouldn't all fit in RAM, so nobody has bothered to do it." That's not (just) the reason. 32-bit x86 CPUs have long allowed up to 64 GB of RAM, with Physical Address Extension (PAE), "total physical address size increases from 32 bits to 36 bits", usable for the OS and all programs combined, but each one still uses 32-bit pointers, thus limited to 4 GB (not total RAM size). I.e. the pointer size matters (not just integers size), and the "[base] pointer" (or in Java "reference") is enlarged in the 64 bit data model. comp.arch (talk) 16:35, 15 July 2018 (UTC)

One more thing, note: "Writes to and reads of references are always atomic, regardless of whether they are implemented as 32-bit or 64-bit values."[1] I.e. 64-bit is supported that way (and is important), as opposed to for integer (or double) types what happen to be 64-bit in length. For such 64-bit values, it's implementation defined (but yes can be atomic, but not to be relied on). comp.arch (talk) 16:51, 15 July 2018 (UTC)