This question is an attempt or organize the various Java governing structures, standardizations, and core cimponents into a coheisive, heiarchical structure that helps explain each piece in relation to other pieces. This question does not pertain to the programmatic concepts. Because the question is broad I am going to first outline my understanding of these various pieces and then base my questions around the perceived gaps in my knowledge. Because this knowledge and cumulative and relational please correct anything that is wrong in my current understanding
The word Java is colloquially used to describe Oracle’s HotSpot JVM. The versioning structure (namely, Java SE 1 through 12) is also a colloquialisn for Oracle HotSpots JVM versions 1 through 12. However, there are many different JVMs (J9, JRockit, ART, Davlik, etc).
The JVM is just a runtime engine. Many distributions offer a development kit that includes the runtime engine alongside a suite of APIs that abstract the internal implementation of the engine and often benchmark tooling, RPEL, etc. Most, but not all, Java development kits are extensions of OpenJDK
While there are many different Java implementations, the development of Java is government by the Java Community Process (JCP) which is a mechanism for standardizing the technical specifications of the language. Specifications are organized into JSRs which are not implementations but rather specifications that are then implemented differently by different development kits. Different Java versions within the same VM implementation differ only in the constellation of JSRs they implement. In other words Java 7 is really Oracle’s HotSpot JVM with a specific set of JSR implementations and a standard API to use those implementations.
However, if you were to compare Java version across different development kits / runtimes (ex: Oracle’s HotSpot 7 v. ART 5) you would not only be dealing with a two different, but overlapping, sets of JSR implementations * but also * the overlapping JSRs, while based on the same spec, would have different implementations (that is abstracted from the user though because they are abstracted further through a standard API). There are steps a spec must go through from when it is sponsored until it is ratified as JSR, and in this regard we can colloquially refer to a JSR as both a specific specification but also a specification process.
Because the spec process is so formal and standardized there exists a precursor for enhancements called the Java Enhancement Proposal (JEP) which is essentially a process that exists before the JSR process.
So before you even get to the runtime / development kit implementation, the enhancement or feature goes through a proposal process. After the JEP it then goes through the process of becoming a formal JSR which includes the specification document itself an example implementation. The example implementation is then subject to a compliance audit by way of the Java TCK. The TCK is basically a suite of test cases for to verify alleged compliance. Finally it is formalized when voted on by a sub committed within the JCP.
There also exists something called the JLS which is a document that defines terms through natural language and by way of example. This is usually released at the level of a release version and may not exist for all Java implementations.
Sitting above the development kit is the ecosystem of Java libraries, platforms, and frameworks used by Java developers (Spring, Struts, LifeRay, etc, etc)
Firstly, I would like to know if there are any glaring misunderstands in the information outlined above? Are there any missing pieces in my understanding that are of a material nature?
Secondly, how well adhered to is this constellation of processes? Do certain development kits implement partial JSRs or work off a different set of processes altogether?
Also, where does Java EE and JavaFX fit in this hierachy? For example, I remember being told many years ago that Tomcat was not an application server because it doesn’t fully implement the standard required to be called an application server (and therefore is called an application container). Is this something unique to Oracle’s HotSpot or is this another layer formalization somewhere, and if the latter are there any processes or bodies that govern that?
Additionally, it seems like the outline above is very heavy on the development kit aspect or Java. But what about the runtime itself? Is there an OpenJDK equivalent of the runtime? I’m speaking about things like Memory management / garbage collection, bootstrap/ classloading, constants pooling, etc? Can the runtime be categorized at a very high level into various components based off mechanics? If so do standardizations exist?
What about the Java Bytecode itself?
Lastly, is there any second hand source that aggregates and clarifies these processes? Ideally something that assumes the reader has a background education computer science and a working knowledge of Java, but not necessarily aimed at the people who have direct experience working inside this framework?
EDIT: Also, what about the security landscape like trust stores, policies, and the security manager? Do these fall more into the runtime or the development kit, and are they universal in all implementations?