Java Pub House

So we had a previous episode where we show a party trick with GraalVM, where we saw how to create a Native Image. It was really the "hello world" of Native image creation, so Bob decided that's not good enough!

In this epidose we dive a little deeper on how to actually run your Restful Web service (or other app) natively, going through the exercise of debugging GraalVM builds including adding Maven plugins, finding out how to quelch the different reflection errors and how to deal with resources (and those pesky JNI / so libs).

In all, this is more of actually a practical use of GraalVM, not just a "it can do it", but more, how is it done. So want ludicruos startup speed and performance? then press play and listen!

http://www.javaoffheap.com/datadog We thank DataDogHQ for sponsoring this podcast episode

Don't forget to SUBSCRIBE to our cool NewsCast OffHeap! http://www.javaoffheap.com/

GraalVM Native Image Options https://www.graalvm.org/reference-manual/native-image/Options/

Maven GraalVM Native Image Plugin https://www.graalvm.org/reference-manual/native-image/NativeImageMavenPlugin/ Apache HttpComponents http://hc.apache.org/

https://www.graalvm.org/docs/getting-started/linux/

GraalVM Resources https://www.graalvm.org/reference-manual/native-image/Resources/

Build Configuration https://www.graalvm.org/reference-manual/native-image/BuildConfiguration/

GraalVM Example Code https://github.com/bobpaulin/javapubhouse-graal-episode/ https://github.com/bobpaulin/opencv-1/tree/feature/add-native-image

GraalVM Native Image InvalidAlgorithmParameterException https://github.com/oracle/graal/issues/768

Do you like the episodes? Want more? Help us out! Buy us a beer! https://www.javapubhouse.com/beer

And Follow us! https://www.twitter.com/javapubhouse

So it happens. Sometimes a Java program just "dies" with the dreaded Out-of-memory Exception. Sometimes, it leaves behind a "heap dump", or a copy of what the Java program had in memory when just before it throw the Out-of-memory exception. For some devs, a heap dump is stressful, because they think is a black box with only mysteries, but we are here to calm your fears!

In this episode we show how Heap dumps are your friends! If you happen to have one, then is almost assured that you can find what caused the out-of-memory, and/or you can "see" what the real values of configuration were. For troubleshooting a production incident, a heap dump becomes invaluable since "nothing" hides from it. Doesn't matter where the code came from, a heap dump will have exactly what each variable was holding and who might be responsible for a memory leak!

"Memory leak you say? I thought java didn't have memory leaks!". Well, that's the other part of this episode where we discuss while Java has way less worries than (say c++) on allocating and deallocating memory, you can still create Memory leaks by having strong referenced objects that are never removed (and if that sounded like mumbo jumbo, even a better excuse to listen to this episode)

So, we survived 2020. Take a listen to this end-of-the-year episode, and be even more ready for whatever 2021 throws at us!

http://www.javaoffheap.com/datadog

We thank DataDogHQ for sponsoring this podcast episode

Don't forget to SUBSCRIBE to our cool NewsCast OffHeap! http://www.javaoffheap.com/

How to capture a Heap Dump https://www.baeldung.com/java-heap-dump-capture

Eclipse Memory Analyzer https://www.eclipse.org/mat/

VisualVM https://visualvm.github.io/

Do you like the episodes? Want more? Help us out! Buy us a beer! https://www.javapubhouse.com/beer

And Follow us! https://www.twitter.com/javapubhouse

We're back! and now we move to the new-fangled serialization and deserialization frameworks, starting with Protobufs! Google's contribution to the serialization space, Protobuf V3 makes it easy to create a very efficient on-the-wire serialized representation of objects, and then some. With the ability to have both backwards and forward compatible changes, protobufs is a great choice for transmitting information across services.

But not to be outdone, @BobPaulin goes in and covers Thrift, which goes a step beyond than just serializing messages, but also takes care of the "Transport layer", adding the ability of doing Remote-procedure-calls! Imagine if instead of saying "I need to send a message to that service, and then the service can process it and send info back", you just said. "I want to call a method on that service with this parameters and get the results". Thrift exposes that functionality by letting you have an interface that you can just call in your client service, and it "magically" coordinates all the gnarly stuff to encode, transmit, execute, decode, and present your call. You don't even have to think (too deeply) about how it all happens. As long as you define your thrift objects, thrift methods, and Thrift transport, the framework will let you just think of methods to call! that's it!

So in all, a very fun episode where we discover what the new types of serialization frameworks are up to. If you ever had to create a message, or ever had to annotate an object as Serializable, then do take a listen to this episode!

FOLLOW US JavaPubHouse on twitter! Where we will be sharing new tech news, and tutorials!

We thank DataDogHQ for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap

• Google Protobuf
• Apache Thrift
• Protobuf Java Example
• Thrift Example
• JVM Serializers performance

Do you like the episodes? Want more? Help us out! Buy us a beer!

Ah, Serialization... the bane of every Java Developer! If you are still using ObjectOutputStream, and Serializable, then you do want to listen to this episode! We move past the objectoutputstreams to what most people are running into these days! (Starting with 2001 and JaxB... and then moving forward from there to Json, and in Part 2...protobuf and thrift!).

But oh, no all serialization is equal, and there are tradeoffs are we go through the different serialization / deserialization libraries (Convenience, Speed, Rigor? all these are things that one need to take into account when choosing a serialization strategy). So take a listen (and watch the video if you want to follow along) as we explore the interesting and great world of Java serialization frameworks!

FOLLOW US JavaPubHouse on twitter! Where we will be sharing new tech news, and tutorials!

We thank DataDogHQ for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap

• Towards Better Serialization (or...why we should skip Java's Native Serialization)
• Introduction to JaxB
• Guide to JaxB
• Jackson Serialization
• Jackson tutorial

Do you like the episodes? Want more? Help us out! Buy us a beer!

Java 14 is out! And with it, we now have a preview of Java Records! We go over this newfangled feature... and get this... we finally did it! We actually recorded our first Video Podcast (Woohoo!). A great episode Number as well (episode 90) to start the road to Video (I know, I know, very 2005 of us), but now you can not only listen to our voices, but actually look at the code as we type so you can follow along!

So yeah, with records, we are essentially incorporating (almost natively) what some of Lombok's @Data features were, including default (sensible) implementations of equals and hashcode. A great episode to not only listen... but to watch! Let us know any feedback you have as we embark into Video (you know where to find us)

FOLLOW US JavaPubHouse on twitter! Where we will be sharing new tech news, and tutorials!

We thank DataDogHQ for sponsoring this podcast episode and providing our Guest Speaker! Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap

• JEP 359 - Java Records
• Records come to Java
• A first look at Records

Do you like the episodes? Want more? Help us out! Buy us a beer!