Beginner

Episode 101. Allright, let’s talk about Kafka

Whew! So we took a big break over summer (like Bob said, we were just swamped with work.. oof), but we are BACK! and like always we are ready to explore even deeper Java topics for the professional developer.

This time we set our sights in Apache Kafka, one of the (if not THE) dominant distributed messaging framework / broker. If you have been integrating webservices, you might have been running into message brokers (and applying Enterprise Integration Patterns), well if so, you most likely have run into Kafka.

We dive into “What does Kafka Solve”, into what it is (and isn’t), and why you should use it (or not use it), and how it differs from traditionalling Messaging systems.

In all, this is another episode of “Cloud stuff”, and, like you know, that’s where everything interesting is at! So have a listen!

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

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

Apache Kafka
https://kafka.apache.org/

Kafka Quick Start
https://developer.confluent.io/quickstart/kafka-on-confluent-cloud/

What IS Apache Kafka
https://developer.confluent.io/what-is-apache-kafka/

Apache Kafka Quickstart (With Tim Berglund, Hi!!!)
https://kafka.apache.org/quickstart

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 100. To the CLOUD… Which one? All of them!

Yeah! so we have been working with the cloud for a while, terms like K8s, EC2, Route53, BlobData, CLI has been swinged around… and is a little mysterious, and sometimes looks like a black box where you just click buttons, add things, type commands, until it finally something good happens. But if something bad happens, we tend not to have the slightest idea on why!

Never fear, on this episode of PubHouse we start from the very beginning on describing (And dismantling) what the “Cloud” really is… Starting on how we got there, what are the different “components” of most clouds, and how to reason about them.

This way, the next time something unpredictable happens, you will know exactly where to start troubleshooting and how to navigate this space! This is the first episode of a series (probably a series of 2) on Cloud technologies. So if you never been exposed to the cloud and you’re curious, or even if you’ve been working on it but everything sounds mysterious, then dive in!


We thank DataDogHQ for sponsoring this podcast episode

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

Intro to AWS
https://docs.aws.amazon.com/whitepapers/latest/aws-overview/introduction.html

What is Elastic Load Balancing
https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html

What is Amazon Route 53
https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html

EC2 vs ECS vs Lambda
https://www.cloudzero.com/blog/ecs-vs-ec2

Intro to Azure Fundamentals
https://docs.microsoft.com/en-us/learn/modules/intro-to-azure-fundamentals/

Azure Containter Registry
https://azure.microsoft.com/en-us/services/container-registry/#features

Azure Compute
https://azure.microsoft.com/en-us/services/virtual-machines/#overview

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 98. It’s HERE, FINALLY HERE! Java 17 LTS Release

So is time to celebrate! We got a new box of toys with the new release of Java! This is also a Long-Term-Support release which means that’s usually a “good one” to jump into! Switch Expressions! Helpful Nullpointers, Sealed Classes… there is a TON that’s new

And we got the best Doctor in town to walk us through all of them. We’re of course talking about Stuart Marks! (AKA Dr. Deprecator). We cover most of the important features from 11 to 17 (there’s a ton that was left out, so keep following the links to know more!)

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

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

Language Features

Pattern Matching for instanceof
https://docs.oracle.com/en/java/javase/16/language/pattern-matching-instanceof-operator.html

Switch Expressions
https://docs.oracle.com/en/java/javase/13/language/switch-expressions.html

Sealed Classes
https://docs.oracle.com/en/java/javase/15/language/sealed-classes-and-interfaces.html

Text Blocks
https://docs.oracle.com/en/java/javase/13/text_blocks/index.html

Debugging Features

Helpful NullPointerExceptions
https://www.baeldung.com/java-14-nullpointerexception

Performance Features

New Garbage Collectors (Shenandoah, ZGC)
https://blogs.oracle.com/javamagazine/post/understanding-the-jdks-new-superfast-garbage-collectors

Unix-Domain Socket Channels
https://openjdk.java.net/jeps/380

Deprecation & Platform evolution

Remove the Nashorn JavaScript Engine (Plug Graal!)
https://openjdk.java.net/jeps/372

Deprecate the Security Manager for Removal and Applets
https://openjdk.java.net/jeps/411

Strongly Encapsulate JDK Internals
https://openjdk.java.net/jeps/403

Warnings for Value-Based Classes
https://openjdk.java.net/jeps/390

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 97. Hey there Scala 3! Looking good with those new Features!

So while Java is the “main” language of the JVM, it is by no means the “only” language. And one of the purely functional programming languages is getting a new facelift!

Scala has been going through a revamp on the syntax and the features, and if you ever run into a scala user you know how passionate they are about their language! (hint: they love it!)

So while we might be working in Java projects most of our time, it is a good time to revisit that developer toolbox and learn when and where to use it. And if anything else, having a dip into a fully functional programming language teaches any budding developer how to see things differently!

So maybe Scala is “not” the language you want to program all your new projects, but understanding its strengs, its thinking (and with Scala 3) and its purpose, it makes it for a very sharp tool to have at the ready when you really need to tackle that Data Sciency / Functional Programming problem.

In addition, we bring one of the biggest names in the Scala Community to walk us through it all @DeanWampler (https://twitter.com/deanwampler) has been working with Scala since the early days and has just published his new O’Reilly book Programming Scala (https://deanwampler.github.io/books/programmingscala.html). So what are you waiting for, add a new tool to your toolbox with Scala 3.0!

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

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

Programming Scala (Dean Wampler)
https://deanwampler.github.io/books/programmingscala.html

New In Scala 3
https://docs.scala-lang.org/scala3/new-in-scala3.html

Scala 3 Features
https://docs.scala-lang.org/scala3/book/scala-features.html

A look at inline
https://medium.com/scala-3/scala-3-a-look-at-inline-and-programming-scala-is-now-published-9690ca43c23a

Safer Pattern Matching with Matchable
https://medium.com/scala-3/scala-3-safer-pattern-matching-with-matchable-f0396430ded6

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 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 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 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 77. Sql or NoSql, To Normalize or to Not Normalize… that (STILL) is the question

Episode 77. Sql or NoSql, To Normalize or to Not Normalize… that (STILL) is the question

So you may have thought about using NoSQL or a Document Database for taking care of you needs. But do you know why that might be not be a good (or a pretty bad idea?). Or you may have a Database that have been running fine, but it seems that you can’t work with it anymore? (Is it time to move to NoSql? Would it help?).

We dive into the “Why” would you choose Databases vs NoSQL Data Stores, or when to ditch your MongoDB and actually come back to MySQL. In our current time of “WebScale” and “CloudReady” we get bombarded by choices! (Mongo, Dynamo, MariaDB, ElasticSearch) and while some of the offerings are great, it might not mean that is the Right choice for what we need to store.

So take a listen as we explore normalization and the strength and weaknesses of relational data vs unstructured data.

We thank DataDogHQ for sponsoring this podcast episode

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 54. Bug Hunt! (The essential skills of the great Debugger)

As a developer, we probably spend most of our time figuring out what went wrong. Debugging really an art, and we sometimes get intimidated by it. Well, if you ever found a bug that has trying to scare you, never fear! Bob and I walk through how to become a master debugger and just Zap those bugs away!

Don’t forget to SUBSCRIBE to our NewsCast Java Off Heap

 

We thank Hazelcast for sponsoring the show! If you need a distributed implementation of the Java collections, no need to look further than Hazelcast!

Follow
Me
on
Twitter! (@fguime) (thanks!)

Man, summer is over! As our side of the earth tilts away from the sun, how about keeping us warm and comfy by sending us a beer?