Episode Archives

Episode 96. Watching Metrics w/Micrometer and Statsd

You’ll run it everywhere there’s a production system. Some kind of Metrics collector like Statsd or InfluxDB. They work like magic, reporting on the health of your application. but how does it really happen?

We dive in on how these Application Performance Management tools work and how do they really “see into” your application. We demistify all this magic, and actually describe how to add “new” metrics and how to publish it!

If you ever worked in a production application, and were wondering how do these metrics get graphed and collected, well, wonder-no-more! We go deep into Micrometer (the SLF4J of Metrics) and how it all works!

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

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/

Micrometer
https://micrometer.io/

Creating Meters
https://micrometer.io/docs/concepts#_meters

Spring Boot and Micrometer
https://spring.io/blog/2018/03/16/micrometer-spring-boot-2-s-new-application-metrics-collector

Statsd
https://github.com/statsd/statsd

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

Episode 95. Ludicruos speed! Practical GraalVM

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

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

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

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

Episode 94. Oh, put on your hat Dr. Watson, we are sleuthing this Heap Dump

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!

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

Episode 93. Not your Grandpa’s Serialization Part DEUX!

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

DataDog Logo
Don’t forget to SUBSCRIBE to our cool NewsCast! Java Off Heap



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


And Follow us! @javapubhouse and @fguime and @bobpaulin

Episode 92. Not your Grandpa’s Serialization!

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

DataDog Logo
Don’t forget to SUBSCRIBE to our cool NewsCast! Java Off Heap



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


And Follow us! @javapubhouse and @fguime and @bobpaulin

Episode 91. OracleJDK? OpenJDK?, Zulu? Corretto? So many!

So just in case you didn’t know, but being a Java developer is as fun as ever! The ecosystem has been changing from the past year, and today, we have “tons” of Java Developer Kits to choose from. Want to know what happened? And want to know how different they are? (or what do they bring to the table), then tune in!

In this episode we cover the history of OpenJDK, and uncover the reason of why there are many JDKs out there. We dive in some of the licensing terms (hint. If you are using Oracle JDK 8, make sure you are getting security updates on with a support plan!).

Then Bob dives into some very fun differences between OpenJDK, Azul, and OpenJ9… and the tool to “keep sane” with all these installations, SDKMan! So if you do Java development for a living (and even if you are a hobbyist) this episode explains all the different Java versions you can play with!

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


We thank DataDogHQ for sponsoring this podcast episode

DataDog Logo
Don’t forget to SUBSCRIBE to our cool NewsCast! Java Off Heap



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


And Follow us! @javapubhouse and @fguime and @bobpaulin

Episode 90. Let’s get Recording (AND VIDEO!)

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!

DataDog Logo
Don’t forget to SUBSCRIBE to our cool NewsCast! Java Off Heap



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


And Follow us! @javapubhouse and @fguime and @bobpaulin

Episode 89. Kubernetes! (Oh container orchestration)

You heard it going around, everybody is talking about Kubernetes, and Minikube, when using Docker, and CLI. It’s like a foreign language! While we know Java very well, with the advent of Devops, we are supposed to be Deployers, and Scalability Experts. Well, once you start going down this episode you’ll become the DevOps Hero your company was waiting for!

Kubernetes is interesting because is a technology that matured almost in tandem with Docker. But Kubernetes is not Docker…Instead Kubernetes manages Docker Containers (among other things). So if you’ve been wondering what exactly it is? and were afraid (or just didn’t know where to start), well, fear no more! We’ll unveil all the Kubernetes mysteries

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!

DataDog Logo
Don’t forget to SUBSCRIBE to our cool NewsCast! Java Off Heap



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


And Follow us! @javapubhouse and @fguime and @bobpaulin

Episode 88. Logging! (An Interview w/Renaud from DataDog)

One of the first things that you learn to appreciate when you transition programming from hobby to a way of life is to find a good way to troubleshoot problems. Most of the time this means logging and monitoring, so for this episode we decided to interview Renaud Boutet who is DataDog’s VP of Product Manager, and don’t worry, he’s really a developer that went to the “Management” (i.e. dark) side, so he knows what he’s talking about!

Diving into topics from Logging Frameworks, to MDC, to a discussion of the three pillars of observability (Metrics, Traces, and Logs), this episode have good advice for everyone. From your first System.out.println (“I’m here”) to your slf4j with MDC setup, you’ll sure learn new tips and tricks!

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!

DataDog Logo
Don’t forget to SUBSCRIBE to our cool NewsCast! Java Off Heap



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


And Follow us! @javapubhouse and @fguime and @bobpaulin

Episode 87. Ok, it’s time to get Reactive!

It’s that Streaming-new-deal that has been taken over the web world, Reactive! You’ve heard about it, and maybe even tried to learn it a couple of times but find it confusing? Well, be confused no more since on this episode Bob and I explore the basic foundations of Reactive (and explain what is that makes is so confusing to begin with)

But that’s not all. We also dive on why is such a “hot” technology and why is the recommended approach on new microservices, even so, we also explore its drawbacks and why we shouldn’t rip everything apart to make “reactive” things.

Lastly we start exploring one of the “reactive” frameworks with Spring WebFlux, and explore how to “think” about Reactive (and came with the marble track analogy). In all, this episode will shed light on a topic that has been hard to understand, but on which, if done correctly can bring a very large performance gain!

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



We thank DataDogHQ for sponsoring this podcast episode

DataDog Logo
Don’t forget to SUBSCRIBE to our cool NewsCast! Java Off Heap



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


And Follow us! @javapubhouse and @fguime and @bobpaulin