Jakarta EE: Present & Future
This is a modal window.
Das Video konnte nicht geladen werden, da entweder ein Server- oder Netzwerkfehler auftrat oder das Format nicht unterstützt wird.
Formale Metadaten
| Titel |
| |
| Serientitel | ||
| Anzahl der Teile | 287 | |
| Autor | ||
| Lizenz | CC-Namensnennung 2.0 Belgien: Sie dürfen das Werk bzw. den Inhalt zu jedem legalen Zweck nutzen, verändern und in unveränderter oder veränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen, sofern Sie den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen. | |
| Identifikatoren | 10.5446/56973 (DOI) | |
| Herausgeber | ||
| Erscheinungsjahr | ||
| Sprache |
Inhaltliche Metadaten
| Fachgebiet | ||
| Genre | ||
| Abstract |
|
00:00
StrukturgleichungsmodellEllipseAppletProzess <Informatik>Expandierender GraphOrakel <Informatik>SoftwaretestOffene MengeOpen SourceSondierungSoftwareentwicklerPunktwolkeServerBenutzerschnittstellenverwaltungssystemQuelle <Physik>QuarkmodellBootenProzess <Informatik>SondierungAppletZahlenbereichGruppenoperationLaufzeitfehlerKartesische KoordinatenHauptidealSchnittmengeDatenverwaltungProgrammSoftwareentwicklerMomentenproblemStandardabweichungSoftwaretestDatenfeldCASE <Informatik>UmwandlungsenthalpieReelle ZahlBitSpezielle unitäre GruppeNegative ZahlMAPAggregatzustandTermOpen SourceOffene MengeQuelle <Physik>CodeDatenflussRechenschieberInformationCoxeter-GruppeSelbst organisierendes SystemSchlüsselverwaltungTemplateBenchmarkInhalt <Mathematik>OrtsoperatorMultiplikationsoperatorSchnitt <Mathematik>EntscheidungstheorieQuantisierung <Physik>Orakel <Informatik>Dienst <Informatik>TouchscreenTotal <Mathematik>Elektronische PublikationMereologieGamecontrollerCOMPunktGewicht <Ausgleichsrechnung>Vollständiger VerbandKreisflächeKonditionszahlStellenringSoundverarbeitungDigitaltechnikMathematische LogikPhysikalischer EffektArithmetisches MittelDiagrammComputeranimation
08:16
SondierungSoftwareentwicklerPunktwolkeAppletServerBenutzerschnittstellenverwaltungssystemQuelle <Physik>QuarkmodellBootenSocketCD-INamensraumStapeldateiDatenparallelitätOpen SourceZeitabhängigkeitStandardabweichungEreignishorizontZeiger <Informatik>Patch <Software>Migration <Informatik>Zusammenhängender GraphDienst <Informatik>SoftwareentwicklerSchnelltasteSerielle SchnittstelleStandardabweichungAppletRelationentheorieQuick-SortMereologieSystemplattformTermVersionsverwaltungOrdnung <Mathematik>Kartesische KoordinatenUnternehmensarchitekturMomentenproblemGruppenoperationSpeicherabzugProzess <Informatik>SchnittmengeBenutzerbeteiligungNamensraumProgrammierumgebungDifferenteOpen SourceEndliche ModelltheorieProjektive EbeneMathematikAdditionDomain <Netzwerk>LaufzeitfehlerWort <Informatik>ValiditätUmsetzung <Informatik>ComputersicherheitProfil <Aerodynamik>GeradeVollständigkeitZahlenbereichUmwandlungsenthalpieComputerspielMaßerweiterungFramework <Informatik>Minkowski-MetrikExtreme programmingNeuroinformatikZeitzoneComputerschachStrömungsrichtungCASE <Informatik>EinfügungsdämpfungAnpassung <Mathematik>PunktTopologieNormalvektorWeb-DesignerWeg <Topologie>MultiplikationsoperatorResultanteBenutzerschnittstellenverwaltungssystemAbgeschlossene MengeOffice-PaketSpezielle unitäre GruppeWeb SiteVererbungshierarchieSchnitt <Mathematik>StapeldateiPunktspektrumCOMComputerunterstützte ÜbersetzungComputeranimation
16:26
GlassFishEllipseOffene MengeUnternehmensarchitekturBenutzerschnittstellenverwaltungssystemImplementierungElektronischer ProgrammführerCD-IAppletDatenparallelitätStapeldateiModul <Datentyp>TransaktionSpeicherabzugProgrammschemaEinfach zusammenhängender RaumDokumentenserverAppletMultiplikationsoperatorDatenparallelitätTermGeradeAggregatzustandOrdnung <Mathematik>Prozess <Informatik>ProgrammierumgebungMailing-ListeWärmeübergangEndliche ModelltheorieGruppenoperationAdditionGüte der AnpassungZahlenbereichDienst <Informatik>Profil <Aerodynamik>StandardabweichungElektronischer ProgrammführerKontextbezogenes SystemEinfach zusammenhängender RaumMechanismus-Design-TheorieBitAuthentifikationKlasse <Mathematik>Quick-SortDokumentenserverPunktKonfigurationsraumMomentenproblemWeb SiteComputersicherheitBildschirmmaskeImplementierungThreadCASE <Informatik>LaufzeitfehlerDatenbankSystemplattformSpeicherabzugApp <Programm>Service providerTeilmengeUmwandlungsenthalpieMereologieEinsMathematikServerZusammenhängender GraphMAPBootstrap-AggregationMaßerweiterungMessage-PassingUmsetzung <Informatik>Luenberger-BeobachterProjektive EbeneNeuroinformatikTropfenSoundverarbeitungSchlussregelKonditionszahlRechter WinkelStapeldateiTransaktionPerspektiveTeilbarkeitSchreiben <Datenverarbeitung>Formale SpracheBelegleserTwitter <Softwareplattform>Orakel <Informatik>ARM <Computerarchitektur>Formale GrammatikSchedulingOpen SourceInterpretiererPartikelsystemComputeranimation
24:36
DatenparallelitätStapeldateiTransaktionCD-IEinfach zusammenhängender RaumDokumentenserverAppletStandardabweichungGruppenoperationDatenmodellGamecontrollerWeb-SeiteServerDatenbankTelekommunikationTemplateQuelle <Physik>GraphCodeEigentliche AbbildungProgrammierumgebungVariablePhysikalisches SystemInformationsspeicherungPunktwolkeVersionsverwaltungRegulärer Ausdruck <Textverarbeitung>Prozess <Informatik>ImplementierungEllipseVorzeichen <Mathematik>AliasingTwitter <Softwareplattform>SpeicherabzugStandardabweichungOffene MengeProgrammierumgebungKartesische KoordinatenKonfigurationsraumNotepad-ComputerInformationsspeicherungKategorie <Mathematik>Prozess <Informatik>Quick-SortUmwandlungsenthalpieOpen SourceVollständigkeitServerGamecontrollerSystemplattformEndliche ModelltheorieLaufzeitfehlerValiditätBitMereologieFramework <Informatik>VersionsverwaltungSichtenkonzeptAppletGruppenoperationStapeldateiTransaktionDimensionsanalyseTermProfil <Aerodynamik>Ordnung <Mathematik>ImplementierungStellenringMathematikHinterlegungsverfahren <Kryptologie>RechenschieberGlobale OptimierungEmulatorAliasingTeilmengeMomentenproblemTwitter <Softwareplattform>Äußere Algebra eines ModulsFormale SpracheSoftwareentwicklerElektronischer ProgrammführerComputersicherheitYouTubep-BlockPunktwolkeSystemaufrufEigentliche AbbildungGeschlecht <Mathematik>AggregatzustandSelbst organisierendes SystemMeterSoundverarbeitungResultanteMultiplikationsoperatorBeweistheoriePunktMultiplikationNeuroinformatikEinfache GenauigkeitFortsetzung <Mathematik>OrtsoperatorExistenzsatzDienst <Informatik>Puls <Technik>DebuggingVariableFormation <Mathematik>CASE <Informatik>Basis <Mathematik>NormalvektorUnrundheitOffice-PaketCOMSondierungXML
32:47
MultiplikationsoperatorComputeranimation
33:18
Computeranimation
Transkript: Englisch(automatisch erzeugt)
00:08
Welcome everyone. This is Jaqarta Iyi, present and future. My name is Reza Rahman. In my day job, I'm principal program manager for Java and Azure at Microsoft. Today's talk, though, doesn't really have much to do with my day job.
00:20
Today, I'm here on behalf of the Jaqarta Iyi ambassadors, as you can see from the slide template. In fact, I'll talk a bit about what the Jaqarta Iyi ambassadors are. Beyond this talk simply being more or less, if you will, a state of the union for Jaqarta Iyi, one aspect of this talk is actually to invite you to be involved in Jaqarta Iyi and begin to contribute to Jaqarta Iyi,
00:44
maybe through the Jaqarta Iyi ambassadors. Either way, on the screen, I do have my contact information. I'm relatively easy to get a hold of. If you have any questions on any of the content that I present today, please do feel free to reach out back out to me
01:00
and I'll try to help you, obviously, in any which way that I can. So let's go ahead and get started with the talk. And the best place to get started is a basic introduction of Jaqarta Iyi, just in case you haven't heard of it before. Jaqarta Iyi is basically the technology that used to be called Java EE. It has now transitioned from the JCP to the Eclipse Foundation
01:22
under the name Jaqarta Iyi. There's nothing in particular wrong with the JCP. In fact, I've been involved with Java Iyi for a very long time in the JCP, and my experience from the JCP has been, I think, by and large positive. But the reality, though, is that the JCP really is not, ultimately,
01:41
a vendor-neutral organization. In fact, it is not an organization per se in any real sense. It's just a department in Sun, and now it's a department in Oracle. So it is definitely far short of what the vendor-neutrality benchmarks today really is. Whereas the Eclipse Foundation and Jaqarta Iyi is, in fact,
02:02
what you would imagine to be open source and vendor-neutral today. It's a nonprofit organization. It does not do anything. It's not affiliated with any particular company per se. So all of the IP, all of the code is completely an open source and not controlled by any particular corporate entity.
02:23
In fact, everyone really has a level playing field, certainly in terms of Jaqarta Iyi. So under Jaqarta Iyi, you have open governance, you have open source, you even have open compatibility testing. Under the JCP, when you wanted to certify something as Jaqarta Iyi compatible, ultimately you needed to pay Sun or Oracle some amount of money
02:42
to get the compatibility test or TCK. So you no longer need to do any of that anymore. Even the compatibility testing is much more self-service than it once used to be. However, though, in the transition process, we did preserve what is actually important in terms of Java EE as an open standard.
03:05
So there's still a well-defined specification process. There is still very clear IP flow of where the IP really belongs, in particular the collective ownership of IP and the vendor neutrality. It is really well-defined to be vendor-neutral
03:23
and a level playing field for all of us. In fact, a level playing field even for individuals. One of the hopes that we all had while moving Java EE to Jaqarta Iyi is actually making things a level playing field even for developers, even for individuals so that we all can also participate in the definition
03:45
and advancement of these open standards and open specifications. So that, I would say, has not really happened. And in fact, if there's one thing that I'd like to change going forward, and hopefully even by delivering this talk, that's what I would like to try to accomplish.
04:02
But the good news is that the key stakeholders that were involved in Java EE that are still involved in Jaqarta Iyi, so Oracle is still involved, IBM, Piara, Pivotal, Red Hat, all of those names, they are still continuing to contribute. In fact, they're contributing in a much more equal way
04:23
as compared to what had been the case under the JCP with perhaps Sun stewardship and then Oracle stewardship. So the key that we would like to solve, and I hope if you take away anything from this talk at all, it is this particular point, is that right now and going forward,
04:42
what is actually key and what is possible is community participation and contribution. So if you want to find out anything much more about Jaqarta Iyi beyond the little bit of an introduction that I just gave you, and hopefully for most of you this is old hat, stuff you already know about, but if you want to learn more,
05:01
the best place to do that is a really nice URL called Jaqarta.ie and you can go find more about Jaqarta Iyi starting from that website. Okay, so before we move too far ahead, I did want to talk a little bit about the importance of Jaqarta Iyi. So one of the unfortunate things about Jaqarta Iyi is there is,
05:21
frankly speaking, a lot of negative marketing around it. Now some of it is warranted, some of it was warranted back in the J2E days, more or less, much less so these days, and frankly a lot of it really is just negative marketing and what I attribute to that being is that there is a lot of money to be made
05:41
and wherever there is money to be made, there are some people that will always fall into the trap of utilizing negative marketing as a tactic. So they'll tell you, oh, it's not relevant, you know, so on and so forth, but it's very far from the truth. When you look at the objective numbers, especially when you talk to developers, and in my day job I certainly do,
06:01
there's real people using this technology set that mission-critical applications are still dependent upon. In fact, if you look at some of these numbers, and one of the numbers that you can cite here is the Jaqarta Iyi developer survey, arguably probably the most important survey for Jaqarta Iyi developers, but even if you look at overall and you amortize it through the rest of the industry surveys out there,
06:26
depending on which survey you look at, about 25 to 35% of applications are still using like a full Jaqarta Iyi compatible runtime. So WildFly, JBL, CIP, WebLogic, WebSiered, Liberty, PyRA, a bunch of people using this stuff today.
06:41
So obviously, this is a technology set that is relevant to those folks. In fact, if you look at the Jaqarta Iyi developer survey, you'll see the higher end number, which is about 35%. Now, let's assume for a moment that you're not using a Jaqarta Iyi server. Does that mean that, oh, this is a technology set that doesn't matter to you anymore? Well, that is also very far from the truth,
07:02
because the reality is a vast majority of people that are Java developers are using and are dependent upon the health and well-being of these technology sets. So about 70 to 80% of Java applications depend at least directly or indirectly against at least one and most likely more than one,
07:23
a sizable number of technologies from Jaqarta Iyi. So whether you're using Spring or Tomcat or Hibernate or ActiveMQ or Jetty or Microfel and Quarkus, believe it or not, at the end of the day, Jaqarta Iyi is something that is important to you, and hence you should be paying attention to the health and well-being of this technology set.
07:43
Making this technology set healthy is what is going to guarantee the longevity of Java, not just for the next 20 years, but maybe in the next 50 years. But that does not happen if we do not pay attention to this technology set, because it is fundamental to keeping the ecosystem healthy and competitive.
08:02
Now, this is also an ecosystem that is evolving, and we'll talk a bit more about that. So the Microfel has played an important role and enjoys relatively decent adoption, even in terms of Java Iyi and Jaqarta Iyi developers, perhaps even beyond.
08:20
And of course there are other evolving parts of the ecosystem that also play a very, very important role. So these are things like Quarkus and Helodon and maybe even Micronaut down the line. And I'll talk more about that when we talk about the concept of Jaqarta Iyi core profile. So a very, very important technology set.
08:40
So as we know, Jaqarta Iyi is not new. It started its life actually as something called JPE. I don't even know how many people remember this anymore. I'm happy to say I've been part of this journey for a very long time myself. I've been involved essentially since the J2E 1.4 days, in one way or the other. And of course I've been involved in developing this technology set,
09:03
ever since at least Java E6, to some extent even Java E5. So for me this has been a very important part of my own personal journey. And of course we've seen many evolutions, and this is in fact a technology set that is evolving and has been evolving and continues to evolve.
09:22
So Java E8 was the last release that was under the JCP. I think it is still a very foundationally important release. I'll talk about in a second why that is. And then there was Java E8. And Java E8 and Jaqarta E8 are basically binary compatible releases.
09:42
They're exact same technology set. The only difference is one is released by the JCP and the other is released by the Eclipse Foundation. And now the current set is Jaqarta EE9. I'll talk more about Jaqarta EE9 and 9.1 in a moment. But that is the current release. And what we are looking at now, and hopefully we will see a release of in just a few months now,
10:06
is Jaqarta EE10. And that is what is going to bring new enhancements and new features. So Jaqarta EE9 so far is really has been about the namespace transition and moving things properly from the JCP into the Eclipse Foundation.
10:26
Now we'll begin to see again the technology set revise itself and add more innovations toward it. Okay, so I think our story will not be complete if we don't talk about Jaqarta E8.
10:41
So Jaqarta E8 was a very, very important release. And it was a community-driven release as well. I was involved in how the scope for Jaqarta EE8 was actually defined. And it was defined by a community survey. So as a result, what happened was Jaqarta E8 is actually a very, very solid foundation.
11:01
It's a very feature-complete release, especially if you're developing monolithic applications more or less. So that is one of the reasons why even accounting for the fact that it has taken some effort, and it's a very significant effort to move things from the JCP to the Eclipse Foundation, to Jaqarta EE,
11:22
Java EE developers really have not been wanting for very much. It is because Java EE8 was actually a very solid feature-complete release. It is also because of micro-profile. Okay, so we all knew that this transition process was going to take some time. And what we needed to do is address the gaps for applications that are microservices applications.
11:46
And that is why micro-profile was created in order to accelerate the development of this technology set and meet the demands of Java EE developers while the transition from Java EE to Jaqarta EE was happening. So looking back, Jaqarta EE8, its major themes were web standards alignment.
12:04
So a lot of things to keep the platform relevant from a web development standpoint and with alignment with standards that come from bodies like W3C. So these are things like HTTP2, service end events, adding JSON to the platform as a first-class binding option,
12:22
just like we have support for Java serialization and things like XML. JSON pointer, JSON batch, I don't know how many of you know this, but even JavaScript and JSON actually are standards. So these are things that are essentially bindings of those standards built into Jaqarta EE, built into Java.
12:42
CDI alignment, so this is gradually moving away from the HTTP component model and centralizing the component model in terms of CDI. CDI2 was a very major release. CDI4 is going to be another major release that is coming in Jaqarta EE10. Pruning, sort of redundant things like JSF-managed beans, some older parts of EJB,
13:05
making more and more of the parts of the platform aligning with CDI, so things like CDI support in persistence, converters in particular, and validators. Making the platform more and more simple wherever it is that we can,
13:20
whether that's through pruning the old technologies like some parts of EJB, or adding a brand new security API to modernize security. That's another important thing that happened in Jaqarta EE8. And of course, one of the most important things that Java EE has always done is to take innovations in Java SE and sort of bring it to the enterprise Java space.
13:45
One of the biggest examples of this is annotations. I don't know how many people are aware of this, but really it was Java EE5 that paved the way of how to really take annotations and make them work in a server-side framework development environment.
14:02
Similarly, same thing has happened with Jaqarta EE8. It did a lot of work to align with Java SE8, which was a very important release. It included a number of important changes, things like repeatable annotations, the daytime API, streams, completable features. So all of those changes were really absorbed into the various specifications
14:24
like faces, persistence, rest, and bean volition, so that you can take advantage of those Java SE features in server-side or microservices environments. So Jaqarta EE9 and Jaqarta EE9.1 is mostly about transitioning the namespace.
14:42
So obviously, because of copyright reasons, we could not continue to make use of the name Java. So you had to come up with a new name, Jaqarta. I think it's actually a very significant name. I don't know how many people of you are aware of this, but Tomcat was essentially donated by Sun Microsystems back in the day
15:02
as part of the Jaqarta project. So Jaqarta is a very significant name, and I think it's a very good name. But in addition to making a change to the name, we also needed to make a change to the namespace. So we really had to decouple ourselves from the word Java in order to move this technology forward into the open source domain.
15:24
So 9.1 did exactly that. So this is about moving all of the namespaces from JavaX to Jaqarta, all in one go. It's just a one-time transition process that we all need to undergo. Some other things also happened with Jaqarta E9.
15:42
One important thing is upgrading the Java version. So upgrading the Java version to SE11 as opposed to Java SE8, which is what was Java E8. And in Jaqarta E10, it's going to be probably baselining on 17, perhaps,
16:01
or at least making it possible so that most applications can be written to Java SE17. So this is all done at this point, and there's a lot of runtimes that actually support Jaqarta E9 and 9.1 already, and we should all be beginning to think about migrating into our namespaces. In fact, a lot of the parts of the ecosystem have already done it.
16:24
Tomcat, JT, Spring, certainly the Java E compatible runtimes, they've already completed the transition. So now it's your turn to do it. So one of the very nice things that has happened is that we have actually grown the number of Jaqarta E implementations
16:41
as compared to Java E8 and Jaqarta E9 now. So all of those are actually listed in this website that I have referenced. But the most important thing is that, perhaps, is that, again, we haven't lost anyone in this transition process. So all of the runtimes that were there before, they are still supporting Jaqarta E and Jaqarta E9 going forward.
17:05
So that will continue to be the case. In fact, I'll talk about this in a moment, but hopefully we will be adding an entirely new class of Jaqarta E runtimes very, very soon also, hopefully in the Jaqarta E10 timeframe in this year.
17:21
So obviously that's current state so far. Now let's take a look a little bit into the near future and the near future is obviously Jaqarta E10. So in the Jaqarta E ambassadors, and we'll talk about the Jaqarta E ambassadors in a moment now. I think this is a good point to talk about that.
17:41
So the Jaqarta E ambassadors were originally called the Java E guardians and actually our purpose was to ensure, especially when, as we were observing, that there were some issues with Oracle in terms of its willingness to support Java E, that is the problem that we tried to solve
18:00
and that is why we came into being as the Java E guardians. And of course we succeeded in that. Ultimately Java E8 was released and even ultimately all of the technologies have moved to the Eclipse Foundation now where everybody can contribute to it. So with the renaming of the technology,
18:20
we also renamed ourselves from the Java E guardians to the Jaqarta E ambassadors. And basically what we were doing is that we were observing that, okay, it's going to take some time for this technology transition process to happen. We all knew that. It's a very, very large core donation. It's well into millions of lines
18:40
and not even going into the huge amounts of IP transfer. It's perhaps the largest technology transfer that was successfully undertaken perhaps ever in our industry, certainly in the history of Java. So we knew that this was going to take some time. So one answer was to move forward micro-profile
19:01
and that was all good. But in addition to that, what we wanted to do in the Jaqarta E ambassadors is really put down our thoughts and collect thoughts from the community as to what we would like to see in terms of technology innovations in the platform. So in order to do that, and again, in order to encourage all of you to begin to contribute towards this technology set,
19:22
we created something called the Jaqarta E10 contributor guide. And in fact, it is still existing out there. And that is basically a listing of all of the possible changes, possible important changes to the Jaqarta E platform that we would like to see. And in fact, a lot of these things are going to make it into,
19:41
I'm very happy to say, is going to certainly make it into Jaqarta E10. If it doesn't, it's going to probably make it into Jaqarta E11. So I'll let you take a look at the contributor guide yourself. It's out there for you as a resource. I'll just summarize at a high level what is in the contributor guide
20:01
and also what you can expect in Jaqarta E10 and Jaqarta E11 and what is actually happening. So one key theme is further CDI alignment. So it's again taking those features that are in EJB and done in EJB-specific ways and democratizing them, making it available to any component
20:21
that is a CDI-compatible component. So this is things like at asynchronous, which is happening in Jaqarta E10, at schedule, lock, max concurrency. These are all different things that can go into the concurrency specification. And some of these will make it in there. There's already conversations to make that happen.
20:41
Decoupling the message ribbon means model from EJB into something called administered listener is something that could potentially happen. Moving things like roles allowed and security into Jaqarta security and making them CDI-compatible. And this is also actually happening as well in Jaqarta E10. There's also scope for better CDI support
21:02
in things like REST, batch, and concurrency. And in fact, again, these are all happening in Jaqarta E10, if not most certainly in Jaqarta E11 as well. There's some, although we've done a lot of work in aligning with Java SE 8, there's certain things that actually still remain
21:20
to some extent. So these are things like adding support for a completable feature in concurrency, adding support for having a bootstrap API that you can just bootstrap it on time in Java SE without a Java E runtime. So this is applicable towards the REST APIs, things like Jersey and REST easy, as well as things like JMS.
21:42
So you ought to be able to take a JMS provider and just run it in a Java SE-based environment. Decoupling the TCKs. So a lot of the, the reason why Jaqarta E or Java E is super evasive is actually a lot of these technologies are usable outside of app servers.
22:00
So you can take them and just use them in a Java SE-based environment. So further modulizing the ones that aren't, and making it possible to certify just a particular implementation or just particular part of a particular technology set, a particular spec in Jaqarta E. Some of that work has been done already, but more of that needs to, could be done.
22:23
And of course there are standardization gaps and I'll talk more about those in a moment. So there's things like that could be done that are just available today in vendor specific ways or in third party components, third party APIs that extend Jaqarta E and these could be brought into Jaqarta E itself.
22:41
So there's some examples of security, batch, concurrency, persistent transactions, all have examples of such things. And of course the core and microservices profile. And that is a subset of Jaqarta E that is basically applicable and making Jaqarta E really work in microservices environments.
23:01
And I'll talk more about the core or microservices profile in a moment as well. And finally some new APIs. So these are some examples would be NoSQL, MVC and configuration. And I'll talk more about each of those in a moment also. So these are some specifics of the standardization gaps that I was talking about.
23:22
So some specific examples are being able to define executor services in a vendor neutral way through annotations. And this is actually happening in Jaqarta E10. Being able to propagate the CDI context along with the rest of the context when you're creating managed threads in Jaqarta E.
23:41
And again this is happening in Jaqarta E10. Adding support for... So right now Jaqarta security has support for database authentication and LDAP. We could add more sort of microservices authentication mechanisms also. So this would be things like OpenID Connect and JWT. OpenID Connect is happening in Jaqarta E10.
24:03
Hopefully now JWT is there in micro profile. Hopefully there is a way to bridge that and bring that into Jaqarta. Doing Jaqarta persistence repositories and in fact there's a proposal for a new spec to do exactly that. In terms of Jaqarta rest using at inject
24:22
as opposed to at context which was an old annotation that sort of behaves like CDI but is not quite CDI. Adding native support for multi-partum form data. In fact this has already happened and it's going to be included in Jaqarta E10. Adding a job-job definition language
24:41
as an alternative to XML. So this would be writing batch specification configuration in Java. And this won't make it in Jaqarta E10 but certainly will most likely make it in Jaqarta E11. And finally transactions. So when people think about transactions
25:00
they really think about 2PC only or two-phase commit. But the reality of Jaqarta transactions in terms of when you look at the implementations is most implementations actually support things like last resource committed optimizations, local transactions, emulation of 2PC
25:21
and a lot of these other more advanced optimizations effectively. Performance optimizations. And they're relatively common place. So it only makes sense to actually add those optimizations back into the standard as opposed to just keeping them sort of vendor specific. So we talked about these new standards so to say.
25:43
One is Jaqarta MVC. So this is an action oriented framework approach that makes it a little bit easier to align with some of the JavaScript heavy front ends as compared with JSF. And there is actually a standard for this already. It's not quite included in the Jaqarta platform.
26:01
In fact arguably maybe it shouldn't be. And it should be added. It should be a part of the Jaqarta umbrella just the way it is. But available basically standalone and being able to be added to any Jaqarta your micro-profile runtime. A lot of the work here is actually just putting together the existing pieces that are already there in Jaqarta.
26:21
So for the model portion for example you could use CDI and bean validation. For the view you could use facelits and Jaqarta server faces or JSP. And really most of the work is in the controller layer. And a lot of the work actually is already done. There is at least an initial version of the specification available under the Eclipse Foundation.
26:43
Jaqarta NoSQL is another one that is almost all but done. The only thing that is holding up Jaqarta NoSQL from being finalized is another portion that I'll talk about and that is Jaqarta configuration. Other than that pretty much pretty feature complete standard already out there. You can use it. Again it's part of the Jaqarta umbrella
27:01
but not included in the platform per se. But certainly usable in micro-profile applications as well as Jaqarta applications. So basically what this does is that it allows sort of a multi-layer approach a flexible approach so that you can use a standard, a single API, a consistent API to access various NoSQL data stores.
27:24
Same thing for Jaqarta configuration. So this is basically the ability to externalize your application configuration outside of your application in things like property files, job assistant properties, environment variables, community secrets,
27:41
NoSQL stores and the like. So there is already a standard for this and has been. This is one of the oldest standards in micro-profile. That is now being transitioned into Jaqarta so that all of the Jaqarta specifications including things like perhaps persistence and NoSQL can take advantage of this. So this again is already in the works.
28:01
My suspicion is that there will be a release of this sooner rather than later this year and it will be included in the Jaqarta EE core profile. So Jaqarta, again I talked about Jaqarta EE 8 being a fairly feature complete release
28:20
for monolithic applications. And so what we need now is addressing the needs of micro-profile developers. So the ecosystem hasn't really been sitting around trying for Jaqarta to figure this out. Basically there are technologies out there that are using micro-profile
28:40
and using Jaqarta EE technologies and making things work for microservices developers in a very, very cloud-native way. So some examples of this is Quarkus or Helodon or even Open Liberty and also perhaps even things like Micronaut. I'll talk about Micronaut in just a moment. But basically these are all making Jaqarta work
29:01
in a fully cloud-native way by basically taking a subset of Jaqarta standards and treating them as a required part in microservices and everything else sort of optional and pluggable. So this is really nothing much more, the core profile is nothing much more than just standardizing that concept. So taking a small handful of Jaqarta APIs
29:22
and saying okay this is the core of what you need in order to develop microservices and above and beyond that you add whatever you want in a modular fashion. So the reason I do have Micronaut listed as part of a possible Jaqarta EE core profile certified implementation is that Micronaut currently is actually involved
29:43
in what is called CDI lite. So that is taking CDI and making it work in a cloud-native fashion, especially with GraalVM. So hopefully once Micronaut in the process of doing that becomes CDI for compatible runtime,
30:03
it's not too far to imagine that it can also add support for the rest of these specs, namely things like JSON and JAX-RS to also become a core profile implementation. And this basically adds a different dimension to Jaqarta EE altogether in terms of what Jaqarta EE can support
30:21
and what Jaqarta EE runtimes look like in a microservices environment. So all of this hopefully interests you and you don't simply need to be interested, you can actually be involved. In fact I hope you will be involved. So these are the different ways that you can be involved.
30:41
And this slide deck is available on my speaker deck account. You can take a look at it and you can explore all of these different ways that you can get involved, beginning from just sharing your opinion all the way to actually helping make some of these changes happen, hopefully some of the changes that we talked about in the Jaqarta EE 10 contributor guide
31:01
for the ambassadors. So in summary, Jaqarta EE 9, 9.1, these are all very important in future-proofing Java and keeping the technology alive and vibrant for many years to come. And above and beyond the transition into a truly open source domain,
31:20
now you will begin to see changes like the Jaqarta core profile and some of the changes that I talked about, whether that's NoSQL or enhancements to existing specifications like security and persistence and moving the platform forward again, begin to actively add new features and actively evolve the platform
31:42
going forward once again. But all of this can happen with you and I hope one part of what you will take away from this talk here today is to be involved and actually make these changes happen. So I'll finish up with some resources for you. First of all, the Jaqarta 1 livestream conference, all of those talks are available on YouTube.
32:02
It's a really good resource to learn more about Jaqarta. If you're going to join one community alias, please make it the Jaqarta-e community alias. A major announcement in the Jaqarta-e platform and major discussions happen there. Please join up there. If you just follow one Twitter handle, I hope you will join the official Jaqarta-e Twitter handle.
32:23
If you follow another one, I hope you follow the Jaqarta-e Ambassador's Twitter handle to stay up to date and stay engaged and find out ways of how you can contribute to the Jaqarta platform. And finally, another monthly, sort of semi-monthly meetup
32:41
that is there for Jaqarta developers is the Jaqarta Tech Talks. That is something else you could be involved in. So that is it for today. That's all I can really cover in a relatively short 30-minute time span. I hope this was worth it and I hope you will reach back out to me if you have any questions or concerns.
33:01
And I hope to hear from you sometime in the future. Thank you very much.