Foojay Podcast #4: Why Are There So Many JDKs?

Transcript

Automatically generated from the audio, so it can contain errors in names and technical terms. Suggest a correction.

[0:00] Hi and welcome to today’s Foojay podcast today we’re going to be talking about the number of different Java distributions in the ecosystem so with the release of Jabba 17 this is a really cool new release with a lot of features now my personal favorite is JDK flight recorder but it also has records and just generally a lot of really good stuff and most importantly this is a long-term support release which means many people will go from java 11 or Java 8 to 17 giving you everything that happened in between but there are a couple ways to get this distribution Oracle offers a JDK under the new free license as well as the GPL distribution Microsoft offers their own JDK distribution based on OpenJDK Azul offers Zulu as a free OpenJDK and Zing is a commercial distribution bellsoft offers liberica a free OpenJDK distribution Amazon offers coretto their free OpenJDK Eclipse offers adoptium and tameru formerly adopted OpenJDK adoptium also offers j9 as a different JDK Red Hat offers their JDK distribution which they just call OpenJDK sap offers sap machine as a free OpenJDK distribution and separately

[1:23] There are other tailored jdks for certain purposes grawvm is a JDK that operates as a hotspot OpenJDK but also steers toward native machine compilation and tornado VM is a VM that intends to run Java on gpus and we’re leaving out Alibaba Dragon well who’s JDK I think merged into adopt now the topic for today is why there are so many jdks how they’re the same and how they’re different as well as how they collaborate and how they compete and I’m really excited today to have a number of guests from different parts of the software ecosystem both Java and appear software language Community to help get a perspective on this ecosystem so my name is Ashley Williams I do not come from the Java Community I’m the peer perspective I am a member of the rust programming languages support team and I was Additionally the founder and original executive director of the new rust Foundation and I’m Simon Ritter I’m the deputy CTO at Azul and I am from the Java community and Java world having joined some way back in 1996 at the same time the JDK 1.0 came out so I’ve followed Java all the way through its history

[2:41] Working at Sun then at Oracle and now it is all right also from java world I work as engineer in belsoft previously in Oracle and before that I participated in many job applications development and I’m Eric costlow I handle developer relations for contrast security focusing on securing applications from the inside to detect their various security vulnerabilities hey everyone I’m I’m Bruno borders I’m on the PM team here at Microsoft and I work with Martin verberg and other folks and I’m happy to be here all right we generally start the podcast by finding certain articles that have appeared on Foojay and I think last year there was an article written by Marcus hurt that was called fantastic jvms and where to find them and what Marcus did was to just summarize a couple of the different JDK distributions that made JDK flight recorder available and had back ported it into jdk8 as well as discussing the organization that provided that JDK and where to get it so Simon can you just give us a recap of that article and certain things in the ecosystem about it yes so what we saw was a few years ago

[4:06] Because it was actually now a few years ago John resc9 came out and that was what Oracle will tell you was the last major release of java meaning that it had several years of development effort behind it what we’ve seen since then is the switch to a much faster release Cadence and a predictable release where we have two releases every year one in March one in September so as you quite rightly pointed out last month we got JDK 17. now as a result of that much faster release Cadence Oracle also made the decision to change from providing updates and providing support for every release to using a long-term support strategy and what that meant was that there were going to be three years between long-term sport releases so every sixth release and they would start with JDK 8 having extended support then JDK 11 and now we have JDK 17. and the significance of that was obviously that we had updates provided for only certain releases the other thing that changed was with the release of JDK 11 Oracle then decided to change the license for their JDK Oracle JDK in the past what users have been used to

[5:21] Is this idea that Java is free meaning that you could go to java.sun.com or java.oracle.com as it then became and you could download the JDK from there and you could use it for free you could put it on your desktop you could put it on your laptop you could put it in your servers in the cloud the only limitations from a licensing point of view at that time were on mobile devices or embedded systems now with the change from What’s called the Oracle binary code license to the Oracle technology Network license agreement with JDK 11 was that there were much more restrictions on where you could use the Oracle JDK for free essentially there are only four places one is personal use if you’re at home playing Minecraft secondly if you want to use it for development or testing then you can do that but for more commercial type of deployments the only places you can use it for free are either with Oracle approved applications meaning they’re middleware and their end user applications or in the Oracle cloud anything else would require the purchase of a Java SE subscription from Oracle now that has led to as you quite rightly

[6:29] Point out a proliferation of distributions of OpenJDK is the open source project that was created by Sun back in 2006 2007 that allowed people to download the source and then build it and make their own distribution covered by the GPL V2 license with class path exception and so you can just download the code and you can run the build scripts and make it available to people under that license and so we’ve seen a lot of companies do that and you can go to bellsoft you can download liberica you can go to Azul you can download Zulu and so on and what that’s meant is that now people are looking at okay so all these different distributions what choices we’ve got which one would I choose and that’s where it leads into kind of making distinctions between these builds in terms of what are the differences but what are the commonalities between them I think the one big thing to get across from this is the importance of What’s called the tck and the tck is part of the Java SE specification that’s developed through the Java Community process each version of java has a jsr Java specification request and part of

[7:40] That is this technology compatibility kit somewhere between 100 150 000 tests depending on which version of java you have and in order to say that this is Java you need to run all of those tests and then verify that you have a compliant version of java right so it sounds like what you’re saying is that each of these distributions maintains a baseline of compatibility so people can just choose and have their application run generally the same whether they choose Azul Zulu or Dimitri bellsoft liberica so how do you to coordinate between different companies but not necessarily by talking but what exactly does the tck do to enable that right so the TK is this very large number of tests which it’s it’s not exhaustive because you’re never going to have a truly exhaustive set of tests but it’s very comprehensive what it gives you is a very high level of confidence that if you take one tck tested JDK and you move your application to another tck tested JDK then the application will run in the same way from a functional point of view it doesn’t mean it will run the same point of view from performance and

[8:55] So on because you can have different implementations you mentioned j9 as it will have a different one called Prime used to be called Zing they still pass the tck but they don’t do the same things internally so you’ll get different performance characteristics but they will have the same functionality meaning you can run the application without having to change the code without having to recompile so that’s the there’s a level of commonality is by using that testing to give you functional equivalence so Ashley how does the rust Community deal with different distributions is it generally speaking that there’s one rust distribution that’s provided by the open source Foundation or are there a couple different rust distributions that are provided by different actors in the rust community yeah so at the moment we have a single release and that releases managed by the teams we now have a foundation and so the foundation is able to kind of be the holder of that the rust trademark policy does not currently allow folks to distribute arrest called rust Beyond just the foundation but I think there’s

[10:07] An interesting there’s been a couple of interesting questions about whether or not we would like that to see that change but yeah for the moment there is the single one that’s run by the rust release team all right so Dimitri as you as bellsoft has liberica that’s OpenJDK distribution and relatively similar to the free Azul Zulu based on what we talked about with the tck what are the key differences between these two distributions that’s a good question first really OpenJDK proliferatives but I would say it started even but even maybe much earlier than Oracle changed the licensing policy because there are so many different users and so many customers with different needs so some to the case at specific needs and teams also work slightly differently for example you may face what we do if you use chat bench products because we also support jetbrain sometime which is one more OpenJDK distribution and if you use for example spring and build your containers you will get liberta there you will get it supported in member tanzu cloud and if you even build spring containers

[11:37] Springboard containers with as native images they will be built by Alberta native image kit core which also contains the berica as its foundation all right so Bruno there was a survey recently that talked about the different JDK distribution that a number of developers were choosing and I know adoptium or adopt OpenJDK was pretty high up in that percentage with a large number of people choosing that as their distribution what should people know about that why was adoptium so popular on these charts and what’s the state of that ecosystem but I believe the reason that drives adopting or adoptable GDK previously known as is the idea that it’s a vendor neutral dedicated distribution that Builds on top of the work of contributors of genders that help maintain the open GDK versions open source versions so we see very hard contributing a lot in the zoo system and those are contributing a lot to different rpgdk JDK update projects so older versions of java that are capped and maintained up-to-date as a business project and then Eclipse foundation and now it

[13:02] Keeps adopting project gets those source code and builds binaries that are considered like vendor neutral so I think that’s that’s one of the reasons that drives a lot of its adoption and usage in the market but of course Eclipse adoption does not necessarily provide any commercial guarantees or commercial support contracts for customers that may require some more like commercial agreements in needs so for the efforts developer it’s something that is interesting but for large corporations because if if a company that has some needs like SLA or compliance or something like that they may actually have reasons to go with a commercial agreement so adopting drives a lot of that usage but does not cover all of the use cases that’s why it’s I find it important to have this Marketplace of OpenJDK distributions with different companies and that’s perhaps the strongest the biggest strength of open GDK project in the Java ecosystem in general so I was talking a little bit about this with Eric ahead of the show but as somebody who comes from an ecosystem that at least at the moment

[14:22] Currently has a single distribution it’s always been curious to me how when folks are choosing a JDK do you find that they are choosing those jdks based on features which could be like performance or some type of support or do you find that the vast majority of people pick based on like price well I’ll end up coming here then ice is it’s it’s one of the last criterias for picking a product in general not just objdk here but a product in general sure it drives decision a lot but it’s it’s not the biggest concern the biggest concern or other things price is like the last thing it’s like when you go buy a car yeah we’ll talk about the price later because it is the last thing that companies look into for they will look into price of course but it’s it’s one of the last things that they will look into first they will make sure that the checklist is not and whatever commercial distribution they have to pack covers this and that and then they will go with price so there is a lot of competition competition in that and I respect Azul systems and bellsoft for you know

[15:39] Competing very strongly with Oracle in this space and having a very solid price competition there but because at least on behalf of Microsoft we don’t charge for the Microsoft video GDK it’s it’s hard for us to say anything further but as a Java developer I would say again it’s it’s good to have the that many options so we can choose which one okay so we have the free JDK distributions like adopt that people can just download but for an organization that needs the full support there there’s typically the paid commercial where you get support and some other features so Simon and Dimitri what are some of those differentiators in Azul Prime and bellsoft libarica that are the difference between the free version which you can get Gratis without paying and the commercial version where you get support plus something else yeah I mean so first thing I need to just clarify there Zoop Prime is a different product so it’s not the OpenJDK one but it is based on OpenJDK but it but it’s not free Zulu is our free distribution and then we have a zoo core

[16:54] Which is the supported version of that when we look at the differences it really comes down to a number of key factors and obviously price is going to be one of those which people do I’m going to disagree a little bit Bruno here people do look at that fairly early on the it isn’t just straight looking at the features they do think about the price as well quite early but certainly if you’re in an environment where compliance is an issue and you need particular support for your software then that’s that’s a key thing but obviously slas are important as well and what I mean by that is that if you’re maintaining software and we need to make a distinction between maintenance and support here if you’re maintaining your software and you need to keep those updates coming through then there’s a real critical thing as to how quickly you get those updates made available and there’s a timing for when updates can be released there’s there’s an embargo on updates up until a certain point and four times a year we get an update to Java which happens in January April July and October so we’ll have an update I

[17:56] Think it’s actually next week I think but anyway so we get an update and when the Embargo ends Oracle will release their update they’re always kind of the first to do that and then other people will follow after that so how quickly you get your updates after that is critical because if you have to wait days or even weeks until an update is made available then because security patches are delivered in the update and the security vulnerabilities the cves that are addressed are included in the release notes that means that the moment that update comes out all of the security patches the vulnerabilities that have been in previous versions are exposed and made public so if there’s a critical vulnerability with the CVSs of 9.0 or 10 then you may want to get that update installed on your systems very quickly so that you’re not exposed to those vulnerabilities and people can potentially break into your system so that timing of how quickly you can get your updates after the Embargo is ended then that’s a real critical factor of that there’s other things as well in terms of like support in terms of how

[19:03] Wide the platform support is whether you’ve got 32-bit versions example if you’re still around Windows XP do you get a version for that will run on there various other things like that are kind of what people will evaluate and I totally agree the same on the support is very important story and people they’ll look at support price and support slas how responsible support this and get quick answers the get updates and free updates and updates for commercial customers they go approximately at the same time not exactly but approximately at the same time again this race is an important quarterly exercise like last release for example America was released right after this occasion was made General generally available which is yeah it’s a challenge and there are many factors really performance May make you thinking of different virtual machine like there’s hotspot virtual machine there is sing there’s j9 very substrate in our space you may decide to use native image right so it may give you some restrictions than you choose it’s so the implementation is not a single one in general world we have

[20:38] Specifications we have testing kits but we are not limited to a single implementation maybe that’s the difference got it so stepping out of the single implementation there there’s Notions of When Things become available when they become supported or when they become unsupported so Ashley what are your some of your thoughts on the concept of long-term support versus short-term support and the overall release Cadence yeah after absolutely so rust is a programming language that has the benefit of coming kind of more recently and so we were able to take a look at how a lot of other languages did their release process and then kind of learn from those experiences and so I think one of the experiences that really drove the rust release process which I’ll explain in a second is the fact that we actually had a fair number of folks from the Ruby world who were participating originally in Rust which I think surprises some people because the languages are quite different in certain ways and very similar in others but Ruby releases on Christmas yearly and that is quite a long release Cadence and it

[21:41] Often leads to this kind of like Rush up of like oh we got to get everything in and honestly I thought about this when I was listening to you all talk about kind of Oracle releasing things and it’s like this big everything rolls up into this one thing and then you everyone’s got to kind of like shift over to this new version and this was something that I also experienced I was originally in the node.js world and for a while that’s kind of how changes just happened and so in Rust one of the things we love our little slogans we’re all extremely online but we have this idea of stability without stagnation and so what was important for rust was we need to be able to change the language but we need to be able to change the language in a way that isn’t going to constantly break people and so we run a six-week release Cadence and we have three release trains one is nightly which is released nightly and then beta and then stable and there’s many little factors within that but they kind of cascade through each other on this Cadence and then additionally we have something called additions which is

[22:47] Where if we need to make breaking changes we’re able to do work within our compiler using an additions flag in the configuration that allows you to use one edition of rust say with a new keyword and a new keyword would be a breaking change with an old version old edition of rust that doesn’t have it and the compiler is able to make those compile together so this is all to say there’s been tons of conversations about what a LTS like program would look like in Rust but we’ve done a lot of work to try and make the need for an LTS significantly less by making it a lot easier for the language to change and for folks to basically be pointing at head without without that being like a constant struggle and feeling like their code is consistently breaking so you can in general kind of like update your rust very very frequently and it is not as tumultuous as an update process as you know you may have in other community ecosystems so I definitely think that’s interesting and I’m kind of curious to hear like if there were if there was like a more frequent like release Cadence for Java and if there

[23:59] Were potentially like less the word breakage in technical communities is a little too negative and I don’t mean it that way but if that was reduced do you think you would see as many of these jdks or are is this proliferation of JDK’s kind of a response to the fact that like transitioning between versions of java it’s complicated yeah it’s it’s interesting to hear that because obviously there’s a very different model being used here and that may be partly to do with rust being a newer language than Java and what we find is that Java being 26 years old now there’s a there’s a lot of kind of and I’m going to use the word embedded but not in the sense of embedded systems embedded Java usage in particular Enterprises and that’s one of the things that is a resistance change there’s a lot of people out there who are still using I mean we have customers who are using jdk6 we have customers using jdk7 we still support them and they just don’t want to move off there because the work involved in taking an application having to re-certify it on a newer version of java it’s like it works so

[25:04] Why do I want to move it to a newer version of java if it it’s just going to work again and go through all that testing so that’s one of the kind of reasons is because we have so many people using applications over the last 20 years then there is this reluctance to sort of move as quickly and certainly the kind kind of customers that I know I talk to when you’re talking to Banks when you’re talking to somebody more conservative with little C customers they don’t want to move very frequently I know there’s you know a drive towards CI CD but there’s still a lot of customers who want for this you know long time between releases and they can make that move I mean it’s the one thing we haven’t actually mentioned here is that with the release of JDK 17 last week Oracle also announced that they’re going to change the Cadence of long-term support releases so we’ve had three years between JDK 11 and JDK 17 and now they want to only have two years between long-term support releases meaning the next one will be JDK 21 rather than JDK 23. so the idea is that you test frequently you could say you

[26:06] Can try out these new versions they come out every six months and then when you need to make that switch from 11 to 17 or 17 to 21 you’ve already done a lot of the testing so it’s easier to make that switch a bottle Simon actually want to jump in here and just add some dated context to this as you cited the organizations that are still on Java 6 I just want to emphasize that was released in about 2006 so things have significantly changed and sped up since then and I think what we’re seeing is people who are on the latest and greatest versions like those who go between you know Java 14 15 16. they tend to be more rapid in their adoption of the newer JDK distributions whereas the organizations that are on kind of their legacy software from the early 2000s or indeed even the late 90s that was a time when you changed significantly less frequently because a lot of people there was not much Broadband they would connect through like America online with their 56 kilobit modems just one thing to add to that it’s interesting to look at the Snick JVM survey that they

[27:12] Did a few months ago and if you look at the usage breakdown that they had in that okay you know it’s a survey so you know take it as as you will but it was very interesting being allowed you to include multiple answers to the questions whereas previously it been one answer for one question and what we found was that you know jdka JDK 11 had sort of similar levels of deployment so there’s still a lot of people using eight there’s still a lot of people using 11 obviously and it’ll be interesting to see how many people move 17. or how quickly they moved to 17. yeah I noticed the big spikes on the long-term support releases it’s interesting to compare speed releasing for example rust and Java so at the same time one is faster and slower than another because if you think of speed of getting next like big version it’s probably slower right with Java as Simon explained people move slowly and versions come out not so often but we don’t have kind of night lists right so again it’s slower but at the same time if someone has for example support contract and needs a fix from some vendor or a

[28:28] Vendor decides to make a fix then we can release fully tested JDK version with that fixed but that would be a custom version of kind of official and that effects goes to OpenJDK and becomes some public change that goes into some update release and update releases are also different probably we’ll talk about that again it may be slower or it may be very fast if you look at the perspective of your risks I think there’s a there’s a fundamental difference between OpenJDK slash Java versus other languages like rust and guard which is those languages are languages and compilers they don’t have a runtime per se like OpenJDK has so that fundamental difference has significant impact in how Enterprises adopt the language the reason one of the reasons Java got to be updated very slowly in the past was because customers and developers were deploying the Java runtime on desktops and servers and then applications would be deployed on top of that runtime so customers were always like concerned oh I cannot just update my runtime because I have several applications I don’t know all of the

[29:57] Applications that are running on top of that runtime so I cannot just go and replace that runtime with the latest and greatest because I don’t know if my applications will break I cannot pass all of them either the applications were already compiled and the byte code will run on top of their runtime but when it comes to other languages there’s no such thing as runtime you just compile the application and run the application to Binary right so that’s also a an important difference and when we talk about open JK from different vendors we’re not talking about different Java languages different versions of General Equity are only talking about different runtimes and patches and enhancements so Azul systems Bell softs Amazon Creator Alibaba sap machine red hat of hdk and so on all of these are just the runtimes to run the bytecode that got compiled for a particular version of the Java language so the runtimes of this of these different vendors do get different patches enhancements that got back ported from the tip of the latest version of java to these older long-term supported versions

[31:09] Of the runtime and that’s that’s a significant difference in why customers don’t necessarily move forward that fast but honestly in recent years I think they’ve seen that customers are more courageous now and they are they have been updating their runtime as much as them in the past okay so the way that the Java handles this structure is a developer compiles their code to byte code that byte code is now designed to run this exact same across each different JDK distribution per the tck which we talked about earlier and frequently there would be a runtime environment and it sounds like some one of the differences or the reasons that we have multiple jdks is due to the focus on jit or just-in-time compilation versus ahead of time compilation and actually with some of the recent changes that have gone on in Java recently with like the creation of custom runtimes through j-link where the JRE is now embedded with the application or gravia native compile something it seems like it’s going to be easier to distribute individual Standalone binaries yes let’s see a lot of hands raised but I’ll

[32:25] Yeah I mean that that’s always been one of the advantages of java having the runtime and I think Bruno made an excellent point there in terms of the fact that is the difference between rust a fundamental difference between rust and Java is the runtime and that’s the thing that people actually want to update it’s not about updating the language quite so much obviously with a compile time thing you can move to a newer version much more easily than you can on the runtime but one of the big advantages and I was having this conversation with somebody just yesterday of java is byte codes not because of the portability that it gives you but the ability to then do just in time compilation and just in time compilation has more opportunities for optimization than you do with ahead of time static compilation there’s things like speculative optimizations that you can take advantage of in Java that you can’t take advantage of in statically compiled code yes you can use profile added optimizations but it’s still not going to give you that level of ability to optimize on the Fly that you get with

[33:29] Jit compilation so there’s things like that and I’m sure Ashley’s going to say something about that I mean I think it is potentially a bold thing to say that it’s it is quote unquote easier to optimize something that’s jitted than not it wouldn’t say easy oh okay I guess what exactly is your thesis before I dive in because I don’t want to argue a point you didn’t make that would be okay it’s easy to optimize I think I say that there’s more potential for optimization there the conversation I was having yesterday was that the P99 conference and Brian Cantrell was there who was talking about rust so it was Ryan and I go way back so yes because I worked at some same times he did on d-trace and stuff but anyway yeah so we were talking about this and it was the whole idea of the optimizations that you can get with a just-in-time compiled versus statically compiled language so it’s the potential is there got it okay I guess I would potentially I’m not necessarily argue with that I think that does make sense I don’t know if we want to talk now about you know just in

[34:40] Time versus ahead of time compilation but I did want to yeah a whole other podcast I suspect but I really did think that the comment that Bruno made was really apt about the idea that when that compilation happens does change the dimensions of the question of like support and like moving things and if you have like a one-to-many relationship of the run time to the application they’re like changing that runtime is potentially more risky and then you wouldn’t want to move as quickly I did want to share it is not quite a one-to-one relationship but because Russ distributes compiled binaries one of the things that we have that perhaps you all experienced Less in the Java world is target support conversations so it has gotten to the point particularly with Russ being used heavily in the embedded space in this case meaning embedded systems We’ve recently had to develop a pretty extensive Target tier policy because the support for those targets has become a massive part of our release Cadence and so we have three tiers of support that kind of indicate the types of guarantees we give for support for

[35:51] That compilation Target so there’s questions about like should rust like compile for Nintendo switch versus like you know like your general like you know Windows machine and there’s really fascinating questions here from like a legal perspective as well as the maintenance perspective and the cost there alone and often the commercial interest I think makes that space very interesting and potentially really similar to like the JDK proliferation situation so I don’t know if folks have thoughts on that but I kind of was considering that when I heard Brian Bruno speaking oh yeah I got a question for you to understand more about rust this concept of target support so you’re saying that it’s possible that I can compile let’s say I want to compile this rust code to Windows and then can I easily reuse that already compiled rust code for Windows for my Windows application that I’m developing or do I have to recompile something here so if that Windows application is written in Rust you might want to recompile because then you can optimize it because if you have something that’s already compiled and

[37:04] It’s like here and then another thing that’s already compiled here you could use them side by side but if you compile them together there’s almost certainly going to be optimizations you’re going to be able to make there that being said I’ve written many clis that call out to other clis it’s a thing that I just constantly do and yes but that works but not but it’s not like a compile library that becomes part of the whole native program it’s it’s just one application calling another application right and if you wanted to compile them together then it would make a single binary but then you’d have to need the source code for that do a single buyer right yes okay so that’s that’s not a that’s another significant difference between between these ecosystems right one of the one of the strengths of the Java ecosystem is the concept of byte code and in having that as already shared compiled code binary as part of like a repository of libraries and then that bytecode can be injected into another application that somebody’s is writing without necessarily having

[38:13] To recompile that library but that Library becomes part of your application of your bytecode as a single thing later and that goes back to silence point on jit compilation that optimization will happen later on so one of the strengths of the Java ecosystem the right code concept and zip completion these combined allowed a Java ecosystem of libraries and tools and Frameworks to grow super fast and notice necessarily having to be open source because you don’t need the source code to leverage that code so you don’t have to recompile that the recompilation will happen on the fly as as native as part of the jit population so it’s it’s it’s interesting to see that these Concepts just drive different forces so for rust to really grow it’s sort of like everything has to be open source where in the Java ecosystem not everything has to be open source and that also allows companies to innovate and drive a few things that doesn’t have to be a business but can be free but well we still allow that optimization to happen on the file one one of the greatest examples of something that is

[39:32] Largely used but not open source is the Oracle driver for the Oracle Java driver for the Oracle database it’s something that is freely available but you don’t have the source code it’s free available in format of byte code but that object but that Library will up be optimized in during the runtime and it’s all made in central anybody can use that their Library yeah I mean coming back to a little bit more to the what we’re talking about in terms of updates and so on one of the advantages that we get from using the byte codes is it does mean that we have less versions if you like because we can provide a Windows on let’s say Intel 64-bit version and that’s all we need and then what happens at runtime is that depending on which micro architecture you’re using then you can use whichever relevant instructions are available for that micro architecture so we don’t have to build specific versions for the specific chip architectures so that we have a proliferation in the sense of that as well so that that’s one advantage of using the byte codes so on a previous Foojay podcast we had

[40:41] Someone who’s working on robotic lawn mowers and one of their early prototypes was actually an embedded system based on Java that literally ran the bike code and so they could run things on their desktop for as much as they could simulate the robot and then deploy it to this thing that was out in the yard cutting a lawn yeah there are several stores about robots and in logistics also implemented in Java there was a company a few years ago that wrote a paper or press release or something that they were running Java for logistic robot control but the back to like Java ecosystem proliferation of OpenJDK when we talk about sustainable open source models the open JK project I just believe it’s a great example that not many people outside the Java ecosystem can observe when we see projects from the Apache Foundation that has most not the most but one of the most commercially friendly licenses there are several projects under that patch Foundation that allow different vendors to provide buyers of their versions of such project and part for that commercial support so the opengdk

[42:04] Project even though it’s GPL too it does also allow such such Arrangements in commercial agreements and that allows different companies to provide different values and also different relationships sometimes it’s not the price sometimes it’s not the features sometimes it’s just like I like you more like the other person so I’ll go establish these commercial agreement with you instead so that’s that’s a powerful mechanism that allows the Java ecosystem to grow both in terms of like open source but also in terms of commercial Arrangements yeah so one other thing that I’d like to add kind of connecting back to this first discussion is in recent years now we when Java 9 got released Oracle changed significantly on how the lpgdk operates in the past we used to see the Java runtime environment and now such concept is not necessarily required anymore for several applications it’s it’s just for in recent years companies like a zoo and also if they do provide a general rundown environment which does not have the developer to use as a convenience for developers that were in that

[43:21] Model before but right now developers can just go with the JDK and what we see is this trend that applications Java applications non-libraries but Java applications should consider embedding a Java runtime with the application itself so the job application gets shipped to the customer with the Java runtime already so if you think about desktop applications one good concept is electron to understand this idea so I go and I create my MSI or my DMG for Mac OS or my dab in RPM for Linux the Java the JVM the Java runtime flows along with my application I I’m not just shipping a jar file I’m shipping a whole thing down to the end user doesn’t even have to know it’s Java in the same way that the user is install a slack in Microsoft teams and Discord and behind the scenes it’s electron but the end user doesn’t know my mom doesn’t know she’s using the electron when she talks to me all the teams but she doesn’t care right so that’s the sort of like idea with Java now where applications especially end user applications that shipped with the Java runtime and for server

[44:41] Side applications that concept is not necessarily a big thing but there is there are ways to optimize the Java runtime for such particular application that will be deployed on the server so that the Java runtime is not a general purpose runtime it’s a runtime specifically for that application so it will only contain the apis required to run that application and some other optimization that can be created generated upon creation so we might see this idea of you know I have to have my job application now with the Java runtime for redoes probably needs and for Mac instead of just having a jar file that is cross-platform but in the library space that concept still continues you just publish your Library without the runtime because the library will be reused by different effects okay so in this case it’s the application owner the person who’s building and packaging it who’s going to make the decision about which JDK their application runs with whether it’s bellsoft Azul Microsoft or adopter Oracle rather than in the past where on a system somebody would install a system-wide JRE and make that decision

[45:49] Yeah exactly like in the past somebody would have to go install Java across 20 000 desktop computers in the bank or in the hospital or in the government office right and then somebody would have to manage that and make sure that they don’t break things so basically that’s why some companies stay with Java 6 for that long because it’s it’s a lot safer but now with this concept being pushed the application is the developer bundles the runtime so we might actually see as I said before like Java updates major updates happening much more frequently because now you can just ship your application with the Java runtime together without the end user having to worry about or without the it manager to have to worry about oh my God no don’t don’t update Java because that will break other applications so that’s that’s one of the nice things about this concept and that’s why I’m I’m part of the team no more Jerry’s all right so as we have no no more jres one of the ways that we can consolidate this and make the ecosystem better for everybody is when companies have an opportunity to

[46:59] Compete as a couple of you do but we also have the opportunity to cooperate in a large-scale ecosystem and really make things better for everybody so Bruno Dimitri Simon Ashley you’re on Rust so I won’t ask you about the JDK what are some of the ways that each company contributes back to the primary OpenJDK project to build this community ecosystem as well as differentiating in their own area so what are some of the contributions that you’ve made back to the core project I would mention the support for Alpine muscle systems that allows to build much more slim containers than we deliver applications to clouds for example like over and other clouds yeah it’s it’s all about being part of a community isn’t it and so what you find is that all the sort of major people who are involved in different JDK distributions will contribute back to the OpenJDK and that that’s really the important thing a lot of that is about the maintenance you know one of the ways that OpenJDK maintains updates is through security patches and those are developed by the vulnerability group in the OpenJDK it’s

[48:15] A closed group even though it’s an open source project it’s closed group and there are Representatives on that group from pretty much all the main distributions so belt off their Microsoft’s there there’s always there red hat Oracle so a lot of the work that goes into creating those security packages isn’t like it’s not just Oracle doing that it’s all the engineers who work on that who contribute to that but then there’s a lot of stuff as well so you know Dimitri talks about the Alpine muscle builds that they’ve been working on is all we do things like we we’ve been contributing to the Apple M1 architecture the new arm processor they’ve got so there’s lots of different things going on there’s all sorts of chaps that are coming from outside of oracles there’s lots of things on that so well hang on Bruno’s asking what is it muzzle muzzle I believe it’s musel okay I’ve heard it we did another podcast yeah but there’s lots of contributions coming from outside it has been back ported to 11 together with Microsoft yeah that’s something that’s in conversations in backboarding some of

[49:26] The Alpine not some sorry the Alpine muzzle support to other versions of java because Alpine Alpine muzzle support only came to open GDK after open gtk 16. at opengdk16 sorry on jdk8 we’ve tried to Upstream the changes to that we haven’t managed to do it yet yeah yeah no Azul and bellsoft have done significant work in importing the changes in Project Portola which is the project that manages the changes in opengk to a support muzzle and that those changes to be Upstream they have to be there’s a lot of work it’s not just oh here’s here’s the patch you know there’s a lot of work that has to go along that so the Upstream project the Upstream update project I’m sorry the Upstream update project for the older version of java there’s a lot of risk in breaking things so you don’t want to break an older version of java that is maintain long term with an LTL swag so that’s the sort of like conversations that you know Microsoft and Bell software having now and Azu is welcome to participate on that as well because I in the cloud space Alpine has seen

[50:41] Significant adoption especially in containers simply because of its footprint of how small it is I particularly don’t see that much of value because it’s cloud and storage is not that much of an issue anymore but customers do want that and we just have to be customer focused and if they want they will get all right so thanks a lot what we set out today was to talk about the number of jdks and explore the concept of why there are so many different JDK distributions and it seems like the theme of what we talked about is that all the jdks are compatible with each other because of tck and the fact that they follow the same byte code standard and that each individual JDK gives an opportunity for that vendor or that provider to build new things like support for Alpine muscle or some other aspects and that the choice of which JDK is used because of j-link and techniques where you ship the runtime is more often made by the application owner rather than the system-wide JRE distribution so the choice of JDK is not from a compatibility perspective but from a licensing usage and kind of an extra

[51:56] Goodie feature but I said that I will throw here and maybe do need a follow-up podcast on this but one thing that I would like to see in different OpenJDK vendors is more like use case focused OpenJDK distributions yeah that’s something that we don’t see yet but I’ll give you an example opjk has too many parameters the JPM I’m sorry the JVM has too many parameters for optimization and tuning and many of those parameters come with defaults so when you run the JVM lots of values have defaults why aren’t why are we still stuck in this concept that the JVM has to have defaults that are general purpose and you don’t know the use case so you just go safe very conservative with those values why don’t we have JVM profiles why don’t we have our OpenJDK distributions or specific use cases here’s an object distribution with the JVM with different defaults for this particular scenario like a server-side applications or client-side applications or a container-based applications or even better characterize applications like i o bound applications or CPU bound applications or memory bound

[53:15] Applications why don’t we have that and that’s definitely perhaps another podcast but I’ll just throw it here so everybody has a struggle managing time yeah we can definitely do another podcast on JDK switches when to use which one why there are so many switches and how to essentially do like a T-Pain style Auto tuning of the JDK yeah because it actually goes back to jdk5 with ergonomics so yeah there’s a whole nother podcast let’s not get into that now let’s talk about that on another podcast because of OpenJDK