 Hvala, da se učili. Imam Mauro Kale, hrvam hrvam solizonarke, včaljim v Italii in PSI, tako imam pred evočnjeh bankov in zilensko. Imam hrvam hrvam vredanje, če povihlju in vse v perej. Počajte, da vse nasjevajte na Twittera in e-mail, včeč, da potrebojamo, da se objezdače, da vse koncerno pridemamo. In da isto bilo, da objezdače, da imaš 3 raptika, da bomo sem umeljali, da sem je pa dvori tako čiče. To je zač jaz, da sem je tudi tudi svoj. Jeste tudi tudi tudi tudi svoj. Svej za to, da sem sem. To je mi, da ne bomo sličaj, in da to je več, da sem je začel, da se se se vse dače, jaz so ta da je zbant, As you can see, one of my favorite sports is professionalism, of course. So, let's start with the thing that we probably used to here again and again. So, it's Java Dev. Short answer, of course, for everybody is no, but let's say that Java is mature enough. And this is what we see at our customer. But it's also true that it's probably not going anywhere. We will see some more points about that in a couple of slides. But basically, at least in our customers is still a standard 90% of the critical workload is on Java in G2 in Fibula. It does, of course, a very large skill base, we will have to articulate more on this in a couple of slides. And also the ecosystem is bigger and bigger because different players are coming. We will talk about Jakarta here, we will talk about a lot of stuff. So, it's basically not dying. Of course, it's mature. It's not a new thing. It's not, let's say, shiny and new, but it's still a lively kicking. This is what we usually bring to customers when it's about Java popularity. Maybe it's a bit blurred, but basically every rankings of languages, you can see. You obey, you can see. Redmon has a rank. Java is still there. There is some JavaScript coming because of Node.js and all the full spec things. There is some Python. Go is starting to be some popularity. But at the end of the day, there is a lot of Java. Yeah, what we notice is that Java has got the main trend. Into our site customer. But the most important thing is that it's not only a mature language, but that is a language that is evolving in a cloud oriented way, for cloud ecosystem, for microservices and distributed ecosystem. The messages that we wanted to share with our customer and the community in general is not only that Java is a language that works well for enterprise ecosystem, but that continues to evolve like the emergence in language that are in the IT ecosystem. Now, of course, it was born a long time ago, 1996. I was growing up in Ajax in that time. So it's not, as I was saying, shiny and new. But yeah, it's a long travel. My customers are there for less. So mostly J2. Maybe not J2.6, but most of the applications are J2. Why are they stuck with J2, or at least they are satisfied with J2? Because of huge applications. They used to buy huge, off the shelf applications of customers once and to run critical services on top of that, like transactions, payments, online banking, whatever. So they are not so happy to move that critical and, you know, painful stuff to different things. They used to have, and they still have, Mootius Agreement with the traditional J2 software vendors, like Oracle, IBM, whatever. So it's basically not convenient for the sake of money. They have some technical debt and no one is willing to pay because it's very common to customer debt, the development teams, they pay for the projects and then they end over to the operation team. But if there is something to fix, like upgrade of the JVM version of the J2V specification and stuff like that, there is no budget for that, because operation is just for the running. They don't have that much amount of money to do huge redevelop forming or anymore of software. They often need specific features that are provided by J2V, like a common example is JCA adapter for connecting to mainframes or things of stuff, or they may need distributed transaction and say that kind of stuff. Of course they have widespread skills and by skills you may also think about the tooling. So as an example, JMX tooling or the kind of things they do for debugging, troubleshooting, Java application is well rooted into the skills and the infrastructure of the customer. And yeah, it just works. So very often there is no big needs for moving that stuff to something different. Something is starting to move from OpenShift because for some reason OpenShift is widespread. At least for lower customers I would say that more than half of the biggest Italian banks but talking also with colleagues all across Europe is true. OpenShift is getting better and better, it's present and people are starting to use it. They are using it in production a lot. And more and more critical apps are jumping in to OpenShift. They started to do simple stuff like lift and shift of Java boss applications but now we do have a lot of customers who build payment system, line banking all that kind of stuff on top of OpenShift so something is moving that and it's the opportunity to look into these applications and maybe make some choice. And when we started to talk about OpenShift I would say 3-4 years ago we used to talk to OpenShift about OpenShift as the new operating system but now it's transitioning into the new application server. This is because things like STO, like K-Native that are providing some features that are no more related to only an infrastructure level but are more closer to the application level so it's no more just the operating system of the cloud. And also give you functionality like for example the H&E that in application server environment are built on top of the cluster environment while in OpenShift is guaranteed by Kubernetes ecosystem functionalities. So most of the orangelist and people working with OpenShift is starting to see OpenShift as the new application server in the ecosystem. And there is also this challenger here which is Spring Boot. Why Spring Boot? Most of our customers run Spring Boot and does this thing like Spring Boot equals Microsoft. Why? This is quite spread. Because it used to be seen as the lightweight alternative to J2E. This used to be true before like EJB3 because it was one of the first frameworks in which you can match the kind of standards or technologies you want to use. But it's not true anymore. Not that true. Even from the point of view of the dimension of the application itself or the memory footprint is not true anymore. J2E is getting better and better and we will see that something is happening in that area. Even in that case the customer, especially in the development teams they have widespread skills because they used to use Spring application before Spring Boot. They used to embed Spring application into J2E application server like in Jbox. We have a lot of Jbox installation in the world that are wrapping Spring things. So people is used to have the skills about dependency in Jax strong using Spring. This creates a very difficult environment because you have a container inside a container that following two different rules. And so in order to try to adopt the new features that Spring guarantees to the customers because evolve faster than the previous version of JEE ecosystem. But the customer are usually forced into the rules of application server or standards that are not aligned to the new version of Spring or Spring Boot that customers would like to use. Another important topic is the supportability challenge because as we were saying most of the customers used to build Spring application and put it into a J2E application server thinking that this will help to have support to the application reality is not true anymore and in the container world is even worse because people are starting to just build fat jars and put it into a container and it doesn't mean that this kind of distribution should be supported by or anything of the commercial vendor. So this is particularly this is like a corner case but it's very important in production environment especially in ugly regulated one like banks. Another important point that Malo was in some ways starting to talk about is the tooling because with the traditional application server people used to have like consults, align things that are in some way standards to do the basic tooling of the application like the thread pools database connection in the Spring world there is no standard for this, it's just something custom so it's not that easy for operation teams to just operate things that are not sitting into a standard container. This is tricky in particular because if you use version like Java 8 that have some limitation on top of container because they are not fully ready to understand the CPU limit the resource limit that you can set into Kubernetes and Docker environments and application server environment can help you to mitigate this risk because the forcing that you can set about the connection pooling of the database connection or thread in particular the number of threads can help you to set a limit that the version of Java that most of the customer use are not able to set as this moment so can help you to fix the limit that you want that your users respect into pass environment. Last but not least, microservices because of course we are living all this microservices history since the beginning and the point is that at some point of time we started to identify one microservice container, which is something still true but the point is that it seems natural to fill these microservices with just a flatjar which we will see may not be the better choice because as an example it doesn't work well with layering of containers, you will not have a layer and then on top of that just things change but you will have this big binary and you push it around and yeah, it's not the best solution so yeah, you of course in the platform is our Jakarta E implementation which is pretty obvious What's Jakarta E in Mauro? Yeah In our opinion Oracle donates the Java EE ecosystem to the community and can help the community to remove the constraints that force the stop of evolution of Java Enterprise Edition that remain for two time too distant for the requirements that the new architecture needs and of the implementation of the use cases that the customer needs in order to reach the business targets The evolution is the Jakarta EE At the moment the version is the Jakarta EE 8 This is the major player players that commit to Jakarta EE but the community is open, we encourage you to participate to suggest the specification that you want to introduce the specification that you want to prove or removed, for example EJB, that most of the community would like to substitute with CDI and transactions API instead of EJB and consider that you can really influence evolution of Jakarta EE in cloud ecosystem environment and participate to this community So what my world was saying is basically that Jakarta EE is having a shorter feedback loop basically so you can have more releases releases more often this is because of course our problems are not the same as ten years ago, so we provide us a different paradigm in developing applications of course you will need a shorter release cycle What we are hearing from our customers is also a lot of confusion because of the transition from Jakarta EE to from Java EE to Jakarta EE the coming of micro profile we will see also quarkus is starting to build some confusion so one of the goals of this talk is trying to put some points about this and trying to clarify some of the relationships between those words Maybe the most important thing that you don't associate Jakarta EE to a vendor implementation but to a subset of specification this is the most important thing because many users confused Jakarta EE has a new renaming brand for Java EE but related to Oracle to Red Hat, to IBM to something vendor is not yet in this way so consider a subset of specification that you need to evolve and to create in the way that best fit your needs, your requirements There is a lot of material about that but basically also the JCR process is changing also the reference implementation that are shifting is changing now there is no and the most important thing is the timeline is changing J4CEP is still alive so it is not going any way and of course is evolving into open shift so those are the most interesting things that we see coming into wireflying Jboss CLI so the first is something directly related to some feedbacks that we got from our customers is the ability to run Jboss CLI things as part of same test of such image build so this is very important because it is better way to customize the image that you are running in production and it is something very, very common for our customers to start installing agents and different things using this procedure, this way Another very important thing is the release we don't understand any time frame about that but basically we are working on it of the open shift operator so we will have a CRD a custom resource definition for a wireflying server that will allow us to do things on QCPL like creating destroying new servers, changing simple things on the configuration ok, so let's switch about micro profile because we will see that there is a flow into these things into this topic because before the introduction of Jakarta EE and in order to respond to the really slow of the evolution of Java EE community create a micro profile that is a community that grouped a subset of specification that are define useful in microservices environment in distributed architecture and then reach this set of specification with a new set of specification that are very useful for microservices in order to make all of your distributed architecture available to run in a cloud native environment here you can see a snapshot of the evolution of the eclipse micro file as you can see we have 11 releases in 3 years so is a very active community as for the Jakarta EE the major players are working on the eclipse micro profile evolution on the right part of the slide you can see a reference implementation of the eclipse micro profile the latest version is the 3.2 as you can see you have the more common API that you can use when you create a micro services so for example JAXRS in order to expose your API your API or CVI for the injection but you can also have this new set of specifications, the metrics the health, the config API, open tracing a set of specification that we usually define as micro servitivities so the subset of the configuration that you need in order to make your infrastructure robust to run into cloud native environment so a lot of new things that are not easy to integrate with the traditional recycle like the J2E standard one that is starting to deal and work in Jakarta IE we will see that but that is basically an independent community working in a parallel way so JBOCAP is embracing micro profile, there are a lot of things we are just looking at the basic one like the health and metrics that is integrated into the Kubernetes and OpenShift infrastructures there is deep integration with all the tooling on the service mesh of OpenShift, Sotiali, Istio, Polygius Pogonizari in things like that and those versions of Welfly I don't know is a version that basically they are starting to embed micro profile specifics into JBOCAP actually we have Welfly 19 and at the moment is Jakarta IE8 fully compliant embrace a subset of specifications micro profile in particular the health in the demo at the end of the session we will show you how to integrate this specification into JBOCAP and traditional environment but the most important thing that you can see here is that what we define usually a brown field scenario so the existing application that you need to evolve but not to completely change are able to be update in a not disruptive way and in this session we will demonstrate how you can do it there is a starter for micro profile so basically a website that just does something similar to an archetype so it helps you build the scaffold of the application why Jakarta IE is different than micro file we are saying that basically they are looking at each other and starting to play together but the whole idea as Paolo was saying before is that micro file has its own evolution which is with shorter list cycles and then from time to time some of the capabilities of micro profile are snapshoted into Jakarta IE8 so this is the ideal governance model that they are putting in place for communities is starting to work right now and we will see how it will evolve if you want to briefly summarize the concept micro file is strictly related to new architecture so micro services and distributed architecture so need to evolve fast like Jakarta IE need to embrace all type of application so the brown field the green field scenario so before to evolve need to guarantee more compatibility but also the new features so now roughly we are talking about weeks Jakarta IE we are talking about months so probably twice a year for releases of course top tape most of you probably know about top tape it used to be our first implementation of micro profile is now shifting into communities in particulars small rye and corpus so it is not going to have its own logo and name anymore and this is in things of customer position of course so putting some more pieces into our picture Jakarta IE EAD is not only the Jakarta IE runtime but is also our micro profile that there is more to have of course everybody knows about this kind of shift so from monolith to micro service functions is not relevant anymore to go into details a bit and of course most of you that was a very interesting talk is wondering about this knows that traditionally well suited into container used to be not the best choice into containers basically because of application density and also of the startup over it so all the class load in teams, all the memory usage things we were talking about the peaks of memory and then the word map that JDM traditionally needs to have to perform at the best so corpus of course is our proposal to overcome all those limitations the first things that is most the most known everywhere is development performance even because the possibility to leverage the program but it's not in our opinion the idea is that it will start and stay into the standard based approach so it's good to have like an ecosystem around at least in micro provide ecosystem in this particular way and it should be to spring in for this reason because it's building a community and ecosystem around open standard so it's not something customized but just one vendor it has an extension mechanism and for this way most of those logos and communities and many more are already integrated into corpus and it's the most important things for our customers we come to the most important topics of our presentation it's providing an easy path from Java Enterprise Edition application into cloud native application because you can reuse skills, you can reuse most of the code in some cases and you can reuse also most of the code of the tooling if you are running one of a JDK as an example so if you have JMX monitoring or things like that you can just what we want to tell you is this Java for the standard edition platform is evolving because I try to fit best all the new features that container architecture give to us but these new features are incremental for example the parameters for intersect the limits the resource usage but not only the JMX and BEAN in order to expose new metrics but all of these things are not inside only one release you can find this from Java 9 to Java 13 but the major vendor support only the LTS version of Java the moments of Java 8 and Java 11 so the customer should choose a JDK version that give me the new feature or I stay to a JDK version that is supported the same thing for the enterprise edition version we showed before that Java EE is evolving that are micro profile but in terms of resource usage in order to control the scale of our application in order to decrease the time to market in order to control our application how can I group by all the new features of Java standard edition and Jakarta EE micro profile without completely change the way of build our application and in our opinion the answer is the use of the specification and works this line is pretty widespread basically nothing to add a lot of start-up and good time and usage of resource you can see some test about REST application and REST plus JD application is just way better than traditional JavaScript how this is possible is just the most essential part is that the workers just move some of the work required for the application to run into the compile time so the runtime is just thinking about runtime and the compilation time is thinking about heavyweight things like class start scanning annotation scanning reflection is not allowed more optimization that usually are in the runtime part in the runtime lifecycle are anticipated in the build time so the framework optimizes some set of features for you in order to give you your application more responsive and have a short usage of the resources into your run environment so split between build time and runtime this means that at its own core purpose consists of basically two parts deployment parts of the core of all the subsystems and the runtime part so it's just optimized for the two different phases this is more or less the anatomy of the core that is the core then there are some other things like index file generation and gizmo then if I'm not wrong it's used as a replacement for reflection things like that you can use it leveraging route so you can just generate a native image running on a system there is the arc as the dependency injection implementation which is not in reflection it's just a lightweight alternative well and there are all the extensions that basically as we were saying are all the third party frameworks that are integrated into varkus so I'm good it supports library load so it's very easy and fun to work in varkus because you can just edit most of the files and see in real time the changes when it's in the development mode you can build fat jars even if as we were saying maybe not a better choice and you can build native executable of course there are some downsides you can use imperative and reactive way of programming so it's just native reacting in some way using vertex and other reactive things it's optimized for very common class of application which are jugs.rs plus jpa and it's cheap subludes for building very easily this kind of create, read, update build applications it's well suited for server less because of the performance so it's very easy to spin up an image with varkus do something and pull it down so for microservices it's Kubernetes native there is a lot of tooling that comes into kubernetes varkus work well outside of container but was born to run into container environment so it's a framework thinking to work on top of Kubernetes and container environment it's a first class citizen this is what we were talking about before so incremental image building you can just add the layers that you need to if you do a fat jar with optimization things it's going away because you just have a very huge fat jar layer every time you change something you have to just spread everything so more pieces to our picture micro profile is going to be is going to be implemented actually it's already implemented but from varkus and enterprise application platform and the micro profile specification will so represent away a bridge in these two words so EAP of course is here to stay for ground building for things that just needs j2e specification in full they are not cloud native or whatever micro profile is representing the good bridge between the two words and of course if you need to server less or cloud native you can just opt to varkus still using something that is standard short summarize to answer a question that customers uses tell to us why I can use jbocep and when I can use varkus we can say that usually you can think about your business domain and the requirements of your application if you start to a completely new application when you can choose the best technologies that can fit the business requirement you can use varkus the recommendation is as you can able to do this follow the specification because in this way you can move from one implementation to another one but if you have an existing one application that you can have deployed on top of jbocep and you can want to move into a container environment for example on top of the open shift and then the couple in order to evolve a subset of this application in a microservices way you can change these pieces of your application and evolve in varkus using micro file specification and in this way you make the two part of your suite able to communicate each other and continue to evolve in a different way but continue to evolve we used to have in the in the old days we used to have customers just developing with pomcat and then deploying things on jbocep which is powerful from a testing perspective and a support perspective with varkus you may be able to do something like that in a better way because you may have your staff just deploying and testing things on varkus using the specification and then you can move to a containerized environment and using the same specification testing it into a g2e environment so you may have all the machine and all the varkus and then okay let's move to demo we realize a short demo we didn't create a doc application for this demo because what we want to demonstrate to you is this thing start from an existing one application built on top of specification and evolve these in the way that we described it before so we use the weather application that you can find in the catacoda website where we have the tutorial for OpenShift environment we start from these we use a code 3D container as local environment in order to have an OpenShift cluster on top of which deploy the different version of our application and we evolve this application with the later release of javai.ee so the 8 varkus and in the varkus version we introduce also the new feature of metaprofile in order to demonstrate also the different of the velocity of evolution because varkus evolve faster than javai.ee as you can see I started that code 3d container on my laptop I log to code 3d console I login as a developer and I don't need any special permission in order to implement what we will show you in this demo we created the DEVCON 2020 projects and we deployed three different two different version of our application the EAP version as you can see the varkus version works on top of PostgreSQL I know, I don't follow a microservices approach because I need to create two different database scheme but for commodity I use only one I login to CRC console in order to work on my project and I show you the code as you can see is a normal model project we create a word distributable file that is based on top of java in the API that will be provided by our application server jazm binding in order to map the answer of our JABSRS API and in this case I integrate the micro profile health specification in order to expose a way to verify the liveness of our application that you can integrate with the liveness and proveness check for example in OpenShift as you can see is a standard JABSRS application we have no proprietary import only standard we have CDI specification JBA specification JAXRS specification nothing of proprietary or related to redact or other vendors the result will be showed in a normal index html file I have a synchronous Ajax invocation of our API this demonstrate as you can have a traditional html file csf3 or client side frontend for your application and this is the health check implementation that verify that our service into OpenShift that post the Postgres SQL is up and running our application available to all the users here the log as you can see the JBO CLP start relatively fast so it's not a complex application but we have a subset of typically specification that you can find in our production application environment this is the final application and you can see the forecast weather for three different countries as I said before JBO CLP at the moment is not aligned to the latest version of micro profile for this reason in order to check the availability of our application so the health micro profile API you need to connect to the JBO CLP CLI so in the demo I connect the POP that host the AP version of the application I connect to the CLI and I will invoke the subsystem that give me the results of the health check configuration these can be easily connected to application monitoring using for example Ansible module in order to connect the health availability with our APM and as you can see our application is available to be reached by our the same application without touch any code will be migrated to Quarkus modify only the POMIXML so it's not a work but it's a jara executable file I set the build of material Quarkus in order to have dependency related to the latest version of the Quarkus yesterday was released the 1.2 so it's not related you need only to declare the specification that you need to use that if you make a parallel with JBO CLP you can consider this as the subsystem you declare it but as you can see from the code, the point on view you have changed your phone cbi, jpa jaseles, then I explain the new 2 annotations that you can see but I didn't change nothing from my application perspective but have all the features that Joseph described before about Quarkus, in fact if you connect to OpenShift here you can verify the install features that are available at the moment that are the equivalent of the JBO CLP subsystem the features that are available at runtime of your application and if you connect to the Quarkus version you have the same application at the running you saw jpa, cdi jaseles, micro profile health this is the concept and the specification give you the opportunity to reduce the impact of the effort needed to evolve your application in order to the couple and give different path of evolution of your business requirements the version of micro profile is different because Quarkus evolve faster so you can verify the micro profile health that with the API exposed so you can attach this on top of Prometheus into OpenShift or your traditional ADM that you use to monitor your production environment to do this we introduced two new features the open tracing in order to have the trace of the invocation of your application as you can see I introduced nothing at code point I only declared dependency at Pomex ML and without doing nothing more the only need that I need to do is to install a jager version into OpenShift in order to have an open tracing implementation my application attached to jager exposed the weather service that is the service that you are that you are seeing now you are able to have the list of invocation of the APIs of your application and that the snapshot of the API that was invoked the subsystem used in order to implement it the HTTP response code and then the total time of the execution of your API the last one will be the matrix it is another specification of a micro profile here the effort is very small because I declare dependency at Pomex ML I introduced these two invotations that you can see are micro file standards so not related to vendor and are the counted that give you the number the times of your API was invoked and the time that give you a snapshot of all the metrics related to your API invotations and the metrics will be exposed through API and you can have the total count of invocation of your API and that snapshot of mean time of execution time of execution and other metrics the same things you can attach this URL to your API subsystem in order to make this metrics stateful because at the moment are stateless so if you restart of the invocation so you need to attach this to an APM in order to make persistent and safe so as you can see the specification is the bridge to reduce the time to evolve so that's pretty much it there is a github repo and if you have any question but before the question a big round of applause to Mauro for being one of the last people on earth using net beans and yes here is the code you can use it as a scaffold to try to experiment any question do you remember have you looked at the amount of memory spending the VALFLA and CORCA's application that would be interesting to see like the difference of the question is about the difference in the user of memory between VALFLA and CORCA in terms of specification is the same because more write will be the reference implementation from the profile for the distribution but in term of execution executable at one time CORCA would be more performant for the reason that we asking about the memory usage the memory footprint from the java side so what the footprint of the java task not what your application is in term of hip CORCA is as a lower user of memory no, because at the moment the reference implementation of VALFLA is not comparable to CORCA because it is related to a JDK8 version or 11-bar traditional OpenJTK version and use a completely different approach of memory usage so it's all comparable the snapshot of comparison is what Juzette showed before in this slide because it's java different not the application server of the square Any other questions? Yeah, I've used or I've been using quite a lot so I'm thinking about what are the benefits of using Qarkus against some kind of Spring Boot application in terms of configuration and all that so the question is about the difference between using Spring Boot and Qarkus so the first part of the answer maybe as we were saying Qarkus may represent a smoother part of evolution like everything into cognitive ones with Spring Boot you may end up providing a big part of the board with Qarkus you may end up using most of your code or at least a big part of your code but Mauro is also looking into this kind of play between Qarkus and Spring Boot Yes, in terms of configuration there are no differences the drive the two frame of following are the same either thinking to work on top of Kubernetes and container environment the difference is and there will be also an evolution of Spring Boot in order to use Qarkus way of working in terms of runtime so some concepts of Qarkus runtime engine will be included into Spring Boot that at the moment are yet available so you can try to use it to experiment it to try in order to have the benefit but it's not a different way of working between Spring Boot or Qarkus it's only that the Qarkus at the moment as Giuseppe explained before give you a path through brown field and green field channel Another thing that I particularly like in the drive direction may end up having a community so you may end up writing code micro-r5.ly and using it on Qarkus or maybe using it on open library whatever you want with Spring Boot you are just What is on the top of the wish list of customers they speak with in terms of missing Qarkus extensions that's a good one I know that Mauro is looking to some implementation for Qarkus that is probably something that is coming the question is about what these customers are looking at like missing things on Qarkus Yeah the Saga pattern is one of the Mauro, very quickly the Saga pattern and the reactive programming because the reactive approach are set into Jakarta E in general API while the reactive as an evolution of a simple way of programming is one of the features that customers ask and that in Qarkus you can find we can continue discussion online Thank you so much