#ToniteWithMe, LIVE and in color, is Gitpod CEO and Eclipse Theia project lead Sven Efftinge from #TypeFox.
If you love #Gitpod, and ever wanted to know some background history of this great FREE ONLINE IDE service, the difference between Eclipse #Che and #Theia, or just have some other burning questions for Sven, then participate in this LIVE SESSION on Friday at 20:00 CET.
Just type your own questions into the chat while the show runs!
If you like this live show, please give it a thumbs up, share it, subscribe to my channel, or become my patreon https://www.patreon.com/mkarg. Thanks! 🙂
#ToniteWithMe chatting about modern #Java is #JavaChampion Nicolai Parlog.
When you want to know what is hot and what is not in Java, then Nicolai defintively is the perfect guest to ask your questions. He will be chatting with me about what is there in the queue for Java, and what already available gems we all should pick up rather eagerly.
Join this LIVE SESSION on Friday at 20:00 CET. Just type your own questions into the chat while the show runs!
If you like this live show, please give it a thumbs up, share it, subscribe to my channel, or become my patreon https://www.patreon.com/mkarg. Thanks! 🙂
The actual performance of the #ForeignLinkerAPI is amazing, once you do one small trick: Resuse native memory! It has the potential to outperform #JNI with whopping 6.8 millions native invocations per seconds already, compared to 7 millions in pure C++, while still being in incubation! #Java really rocks!
This video was produced with a pre-release of #JDK16.
If you like this video, please give it a thumbs up, share it, subscribe to my channel, or become my patreon https://www.patreon.com/mkarg. Thanks! 🙂
The #ForeignLinkerAPI, which is in incubation in #JDK16, was announced to be as fast as, OR EVEN FASTER AS, #JNI (#JavaNativeInterface, the sole OFFICIAL way to call native code from Java). But how looks the realitity? See an ACTUAL performance shootout of the Foreign Linker API vs JNI, AND VERSUS #JNA (#JavaNativeAccess, the DE-FACTO way for invoking native code from #Java). I don’t want to spoil TOO MUCH, but prepare yourself for adopting the new API AS SOON AS YOU CAN…!
If you ever wanted to know the correct pronounciation of “Eclipse Theia”, stay tuned for this week’s LIVE STREAM on Friday 20:00 CET: My guest in #ToniteWithMe this week is #Gitpod CEO Sven Efftinge from TypeFox!
If you like this video, please give it a thumbs up, share it, subscribe to my channel, or become my patreon https://www.patreon.com/mkarg. Thanks! 🙂
The #ForeignLinkerAPI of #JDK16 allows to invoke native code, typically DLLs or shared objects written in the C language, without neither a #JNI wrapper written in C, nor a third party library like #JNA.
Due to its cross-platform nature, Java never was a “good citizen” on any operating system. Besides the UI, which never really looked “native”, you mostly noticed this when it comes to calling native binary code. While you could write special libraries in C that fulfils the JNI contract, this is not what you actually wanted: Calling already existing THIRD PARTY libraries, like the Windows API for example. JNA and other libraries improved this, but were not as fast as JNI on one hand, and were not part of the official platform, so just replaced custom static glue code by third-party dynamic glue code. Still at runtime some JNI mumbo jumbo had to go on to copy data between the Java heap and the native heap, which is rather slow. And the worst thing is, JNA was only available for a small set of platforms, WAY less than the lots of platforms Java runs on!
With JDK 16, the Foreign Linker API (and its twin, the Foreign Memory Access API) enters the stage, and this will be a real game changer! While it still is in incubation, which mean it will definitively change over the next few JDKs before it will be stable, it already shows its powers: It is deeply built into the Java runtime itself, and it natively links the loaded native binary code with the Java runtime itself. Just like keeping the Java interface, but providing the actual native code as the implementation. Due to that, it is at least as fast as JNI (possibly fast as potentially less data is moved or converted between the OS memory and the JVM memory), can load ANY third party code, hence does not need a custom DLL to be written by you in C, nor does it need a third party glue code like JNA. Data binding works directly with the native heap using the new Foreign Memory Access API, so it prevents the expensive Java code mirroring unless actually needed. As the whole glue code is written in Java, and both APIs are part of the JRE, this API works on ALL platforms without any third party stuff or glue code in C!
Ain’t that f*ing great?! Guys, I waited for this since decades! Yes, JNA was ok, and I even contributed to it. But the foreign linker API and foreign memory access APIs is what we all REALLY want. It just feels so good! Try it out AT ONCE!
If you like this video, please give it a thumbs up, share it, subscribe to my channel, or become my patreon. Thanks!
The new pattern matching enhancement for the instanceof operator in #Java16 spares you a lot of typing, and makes the code more concise and much easier to understand!
#JDK16 is stable and will be released in March. Time to look into the new PATTERN MATCHING functionality that it brings for the instanceof operator. Turn five complex code lines into a simple single code line, and spare a lot of typing and potential failures! I will show you in this video how amazing modern #Java source code looks like when using this new syntax!
The record keyword is ready for production use in JDK 16, which officially will be here mid March. Spare lots of keystrokes and get rid of code generators and IDE magic with this new keyword!
In addition to spare typing, your Java source code also is getting much easier to maintain and to understand, as it is so concise and fully integrated into the compiler and the runtime. While, besides of shorter source code, there is no measurable speed gain or reduced binary footprint currently, I could imagine that in future the runtime could further optimize records, as it knows that records are definitively immutable and non-extensible.
Maybe project Valhalla will then treat them as primary data types, as they already are best suited for passing around pure values — so your code would run in double speed consuming half the memory?
Sitting in a f*ing cold studio I wonder what video you would love me to record next!
The year 2021 is here, and I am bringing modern and cloud-native Java to some of my favorite open source projects: Speeding up Maven by using Multi-Release JARs with support for Java 9 and 10’s improved NIO API, quickly booting and small-footprint REST microservices with standalone JAX-RS 3.1 in Kubernetes, Java 11 support in Jakarta EE 9.1, and much more!
But where to start…? What videos do YOU like me to post next? Write your favorite video topics in the comments section belows this video!
Backporting an application from Java 15 to Java 8 to convince you how much better coding in modern Java is!
Java 15’s modern language features and API enhancements makes coding so much better!
In this video I am migrating a JAX-RS application from Java 15 back to Java 8 to demonstrate how great the modern code is like, compared to the functionally identical code in the ancient pre-Java-9 world. You will see the difference in lines of codes spared due to using the var keyword, switch expressions and the Map.of() factory method – just THREE features out of a whole bunch of improvements! In the end, Java 8 was not just slower in its execution, it also forced you to write much more code, less comprehensible code, was more error-prone, and enforced complex construction, compared to Java 15. In addition, you had to scroll around a lot as you had to put some code into extra methods. Also the old-school code had much more potential bugs and even some were not even detectable at compile time!
Adopt modern Java NOW and start to use all the new features to get better, faster, more concise, more readable, and more bug-free Java code in less time!
You even can do that in existing libraries thanks to multi-release JARs, like Maven currently is adopting it, or on Jakarta EE 9.1 which officially supports Java 11 and will be released in few weels! Chances are good that your application server ALREADY allows modern Java, as e. g. Eclipse Jersey is supporting this already since several releases (this video actually proofs this)! And your favorite IDE definitively DOES support Java 15 already!
So there is no more excuse to wait any longer: Start using Java 15 NOW!
