Java Pub House
This podcast talks about how to program in Java; not your tipical system.out.println("Hello world"), but more like real issues, such as O/R setups, threading, getting certain components on the screen or troubleshooting tips and tricks in general. The format is as a podcast so that you can subscribe to it, and then take it with you and listen to it on your way to work (or on your way home), and learn a little bit more (or reinforce what you knew) from it.
info_outline
Episode 104. It's all about Apache Tika, the project that lets you index EVERYTHING.
04/19/2024
Episode 104. It's all about Apache Tika, the project that lets you index EVERYTHING.
So we continue to have guests in our show to talk to us about interesting things... This time is about Apache Tika. This is an incredible tool to do search file processing and metadata extraction. Think about that you have tons of unstructured files, like emails, or documents, and you want to extract, index and then search theses. This is Tika's purpose. And who best to walk us through how it does its magic that its Project Management Committee (PMC) Chair, Tim Allison! So take a listen as we go deeper on ingesting tons of content (which is fundamental for things like training LLMs). 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 Tika * https://tika.apache.org/ OpenSearch Project and OpenSearch Neural Plugin Tutorials * https://opensearch.org/ * https://opensearch.org/docs/latest/search-plugins/neural-search/ * https://opster.com/guides/opensearch/opensearch-machine-learning/how-to-set-up-vector-search-in-opensearch/ * https://opster.com/guides/opensearch/opensearch-machine-learning/opensearch-hybrid-search/ * https://sease.io/2024/01/opensearch-knn-plugin-tutorial.html * https://sease.io/2024/04/opensearch-neural-search-tutorial-hybrid-search.html Selected Advanced File Processing toolkits/services * https://unstructured.io/ * https://aws.amazon.com/textract/ * https://azure.microsoft.com/en-us/products/ai-services/ai-document-intelligence Selected Hybrid Search/RAG toolkits (there are _MANY_ others!) * Haystack: https://haystack.deepset.ai/ * LangChain: https://www.langchain.com/ * LangStream: https://langstream.ai/ Search/Relevance Conferences * https://haystackconf.com/ * https://2024.berlinbuzzwords.de/ * https://mices.co/ Tim's personal project * JavaFX (ahem) tika-config writer UI: https://github.com/tballison/tika-gui-v2 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/index/show/javapubhouse/id/30894678
info_outline
Episode 103. Let's share data cross-language with Apache Arrow! (among other things)
03/19/2024
Episode 103. Let's share data cross-language with Apache Arrow! (among other things)
We have a great time talking to Matt Topol from Voltron Data on one of his Apache Software Foundation projects called Apache Arrow. It's both a spec and implementation of a columnar data format that is not only efficient, but cross-language compatible. We walk through the scenarios that it covers and how is becoming more and more pivotal for things like ML and LLMs. So come listen to this JPH episode on one of the best and free ways to distribute data and integrate services working on top of that data! 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 Arrow Project (https://arrow.apache.org/) - Java implementation (https://arrow.apache.org/docs/java/index.html) - In-Memory Analytics with Apache Arrow (https://www.oreilly.com/library/view/in-memory-analytics-with/9781801071031/) - Matt Topol X (Twitter!) Account (https://twitter.com/zeroshade) - 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/index/show/javapubhouse/id/30431458
info_outline
Episode 102. Oh my... Spring Boot 3 is out! An interview with Dan Vega from the Pivotal Team!
02/16/2023
Episode 102. Oh my... Spring Boot 3 is out! An interview with Dan Vega from the Pivotal Team!
Ok, so it's an incredible time to be in the Java Ecosystem, and one of the biggest frameworks out there just dropped their three-point-oh version! That's right! So Spring Boot is not officially 3.0, and it has as a Baseline Java 17! (oohh!!). So we brought in the big guns to talk about what does it mean to Upgrade to Spring Boot 3, and what are the new cool toys we can expect from that upgrade! In all, an amazing interview full of great things that are available NOW (so whatcha waiting for! Upgrade!) 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/ - Dan Vega's own What's new in Spring Boot 3 (https://www.danvega.dev/newsletter/whats-new-spring-boot-3/) - Official Spring Framework 6 Wiki (https://github.com/spring-projects/spring-framework/wiki/What's-New-in-Spring-Framework-6.x) - Spring Boot 3, and Spring Framework 6, What's new? (https://www.baeldung.com/spring-boot-3-spring-6-new) - Spring Boot 3 goes GA (https://spring.io/blog/2022/11/24/spring-boot-3-0-goes-ga) - Preparing for Spring Boot 3 (https://spring.io/blog/2022/05/24/preparing-for-spring-boot-3-0) - 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/index/show/javapubhouse/id/25949427
info_outline
Episode 101. Allright, let's talk about Kafka
11/08/2022
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! We thank DataDogHQ for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast OffHeap! Apache Kafka Kafka Quick Start 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! And Follow us!
/episode/index/show/javapubhouse/id/24939585
info_outline
Episode 100. To the CLOUD... Which one? All of them!
02/09/2022
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! 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/index/show/javapubhouse/id/22074917
info_outline
Episode 99. SHHH! It's a secret! (Storing API Keys / Passwords / tokens!)
01/01/2022
Episode 99. SHHH! It's a secret! (Storing API Keys / Passwords / tokens!)
Ok, so is time to talk about something secretive! Like API Passwords, Auth tokens, or keys... these are things that we want to have as a Secret within our microservice. And yeah, adding them into your source code is a big no-no Here we cover the dos (and dont's) of secret management, what are the benefits and drawbacks of the different solutions and we explore some of our favorite open source (and Cloud tools) for keeping secrets. We answer some important questions on how to effectively store and manage these secrets (the short answer is don't try to do it yourself!), and end up with the list of best practices for it. If you are building a non-trivial (or interesting) web service, this is a must-listen episode! 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 Using AWS Secrets Manager to manage secrets in Spring Boot https://raymondhlee.wordpress.com/2019/10/11/using-aws-secrets-manager-to-manage-secrets-in-spring-boot-applications/ AWS Secrets Manager https://aws.amazon.com/secrets-manager/ Spring Cloud AWS https://cloud.spring.io/spring-cloud-aws/reference/html/ Hashicorp Vault https://www.vaultproject.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/index/show/javapubhouse/id/21649052
info_outline
Episode 98. It's HERE, FINALLY HERE! Java 17 LTS Release
10/05/2021
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/index/show/javapubhouse/id/20708747
info_outline
Episode 97. Hey there Scala 3! Looking good with those new Features!
07/08/2021
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/index/show/javapubhouse/id/19741379
info_outline
Episode 96. Watching Metrics w/Micrometer and Statsd
05/10/2021
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 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/index/show/javapubhouse/id/19047980
info_outline
Episode 95. Ludicruos speed! Practical GraalVM
03/06/2021
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 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 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/index/show/javapubhouse/id/18215954
info_outline
Episode 94. Oh, put on your hat Dr. Watson, we are sleuthing this Heap Dump
12/31/2020
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! How to capture a Heap Dump Eclipse Memory Analyzer VisualVM Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us!
/episode/index/show/javapubhouse/id/17384504
info_outline
Episode 93. Not your Grandpa's Serialization Part DEUX!
11/08/2020
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 on twitter! Where we will be sharing new tech news, and tutorials! We thank for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/16727876
info_outline
Episode 92. Not your Grandpa's Serialization!
08/31/2020
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 on twitter! Where we will be sharing new tech news, and tutorials! We thank for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/15816947
info_outline
Episode 91. OracleJDK? OpenJDK?, Zulu? Corretto? So many!
06/26/2020
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 on twitter! Where we will be sharing new tech news, and tutorials! We thank for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/14973380
info_outline
Episode 90. Let's get Recording (AND VIDEO!)
05/19/2020
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 on twitter! Where we will be sharing new tech news, and tutorials! We thank for sponsoring this podcast episode and providing our Guest Speaker! Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/14477855
info_outline
Episode 89. Kubernetes! (Oh container orchestration)
04/13/2020
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 on twitter! Where we will be sharing new tech news, and tutorials! We thank for sponsoring this podcast episode and providing our Guest Speaker! Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/13962035
info_outline
Episode 88. Logging! (An Interview w/Renaud from DataDog)
01/23/2020
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 on twitter! Where we will be sharing new tech news, and tutorials! We thank for sponsoring this podcast episode and providing our Guest Speaker! Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/12857600
info_outline
Episode 87. Ok, it's time to get Reactive!
11/05/2019
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 on twitter! Where we will be sharing new tech news, and tutorials! We thank for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/11913170
info_outline
Episode 86. Move Over Slow Startup times, GraalVM...IS...HERE. (and cross-language support, and less memory footprint...)
10/01/2019
Episode 86. Move Over Slow Startup times, GraalVM...IS...HERE. (and cross-language support, and less memory footprint...)
Oh my! This episode is going to be one of our favorites. There are times where the Java ecosystem delivers something incredibly interesting (InvokeDynamic, Lambdas, Streams, Kotlin), and this episode is one of those! You may have heard it mentioned around the interwebs or conferences (this new GraalVM thing)... well, it's here to stay and is propelling JVM languages to a whole new level of interoperatibility and performance! So GraalVM at the very high-level view is a "Java Virtual Machine" (in reality there's much more to it, but we can at least start there). It provides tons of interesting features, like the ability to not only compile Java/JVM languages, but also Javascript, LLVM Languages (like C++), Python, R (and is expanding to others), and more importantly, interoperatibility between all these languages. But the bee's knees (or the most interesting fact) is that GraalVM also have the "Native Image", which allows you to completely bake in a Linux (more platforms coming) binary straight up from your source code. The Native Image doesn't require Java to be installed, and you can start your application as you would any other Linux executable. The most impressive part? Startup times are incredibly fast! So we have usually addressed tons of misinformed myths of the Java language like "It's slow:" (No, not really), or "You can code more performant code in C++" (possibly, but you have to be an expert to squeeze more performance than the JVM's JIT compiler). But one area that the claim has held true is that "Java has slow startup times". And (it used to be) true! Because of the dynamic classloading that Java supports, it's very hard for the JVM to startup fast. For long running applications this is usually not a problem, even so, for the new Cloud folks (and Lambdas, and AutoScaling Groups), fast startup time is a "thing". And so, with GraalVM (with some caveats) we are conquering one of the last arguments against the JVM languages. In all, THIS is the episode to listen this year. It's exciting, new technology that we could really spin up and use. Let's have fun programming again with GraalVM. FOLLOW US on twitter! Where we will be sharing new tech news, and tutorials! We thank for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/11459870
info_outline
Episode 85. Monitor the World with JMX!
08/16/2019
Episode 85. Monitor the World with JMX!
There are technologies that sometimes are forgotten in a lonely corner, but that actually are quite sturdy. One of these is the All-Powerful Java Management Extensions (also known as JMX). With JMX you can actually expose a lot of metrics of your application and TONS of libraries use it "out of the box". Libraries like Tomcat, JVM, ActiveMQ, Spring (and ton others) exposes their metrics through JMX. And you can too! In this episode we go over how to both consume JMX metrics (through JConsole, or statsD, or other Performance Monitoring Tools), and how to produce them as well (By creating your own MBeans), not only that, but we also go with how to be able to "invoke" these on a live application. Have you ever wanted to say "Oh my, I wish I could call this method while the program is running in production 'At will'". Well, with MBeans, you can make that happen! Not only that, but if you really want to you can also expose your MBeans through a Rest Endpoint with Jolokia. FOLLOW US on twitter! Where we will be sharing new tech news, and tutorials! We thank for sponsoring this podcast episode We also thank for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/10896419
info_outline
Episode 84. Let's get down and dirty w/Netty!
07/09/2019
Episode 84. Let's get down and dirty w/Netty!
So you get that project that needs to connect to a server that doesn't talk rest, or http(s), but has its own protocol (or maybe it DOES talk https but you are looking for incredible performance!). Well, look no further than Netty! Sure, sure, you could really spend time working with NIO.2 and creating your own sockets and all that jazz, but why? The Netty.io folks already did it, and by golly they created a library that's "blazingly fast". So take a dive into this episode where we talk about the main netty concepts (like pipelines and handlers), and give you a tip or two as you embark down into protocol performance bliss. Netty has seen it all, and has been battle tested for a while now (Have you heard of Jetty? well, that has Netty under the hood), and best of all, we go over how to be "lazy" about it! Netty really implemented a lot of protocols, events, and stuff already (for example LengthFieldBasedFrameDecoder, ProtobufVarInt32FrameDecoder, SslHandler, WebSocket00FrameDecoder and much more!), so you don't have to be the wiser and implement things from scratch... chances are... Netty already has them (or at least will have the right tools to create your own thing). FOLLOW US on twitter! Where we will be sharing new tech news, and tutorials! We thank for sponsoring this podcast episode We also thank for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/10453151
info_outline
Episode 83. Hey! Your app needs its yearly HealthCheck as well!
05/21/2019
Episode 83. Hey! Your app needs its yearly HealthCheck as well!
You got your new project, it's a brand new service, and is ready to go! But... have you done a health check endpoint for your app? In this day and age of microservices with auto-remediation and auto-scaling, having a well-behaved, functioning health-check is very important since it dictates when to evict, scale up (or down) your service. And the great news is, that for the "bigger" frameworks (like Spring or Microprofile) the work is almost done for us! With Spring Boot Actuator and Microprofile, we have tons of support and annotations, and built-in healthchecks for the main "things", like database connectivity, Message Queue connectivity, even Email settings!. So don't put it off...start listening to this podcast, and then start creating that oh-so-needed health check for your app! Also, stay tuned to this episode as we give a "hint" of new podcast series to come! FOLLOW US on twitter! Where we will be sharing new tech news, and tutorials! We thank for sponsoring this podcast episode We also thank for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/9861893
info_outline
Episode 82. Uh-oh Spring... you got some serious competition from Micronaut!
03/29/2019
Episode 82. Uh-oh Spring... you got some serious competition from Micronaut!
So the internet is all raging about this (not so little) framework that is doing it all. Created with a "cloud-first" mentality, is aiming to be your next Spring Boot! And, oh gosh, how easy they are making it. We dive into what makes Micronaut such a darling of the internet right now (not using reflection, ready, better memory consumption) and see how much "stuff" is in there (the TLDR; ). We go from creating a microservice, to looking at the different already-implemented features like circuit breakers, properties/profiles, beans, support for lambdas, micrometer, reactive programming, and all. While it might not have "everything" that Spring does, the reality is that it's pretty solid. Would you consider Micronaut for your next project? The answer is maybe (and for some cases, maybe Yes). So come, and take a listen to the underdog framework (Micronaut) that's stepping up to definitively take the reigning Champ (Spring) FOLLOW US on twitter! Where we will be sharing new tech news, and tutorials! We thank for sponsoring this podcast episode We also thank for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/9187772
info_outline
Episode 81. Let's Dive into a cool magical library that makes Java way less verbose!
03/03/2019
Episode 81. Let's Dive into a cool magical library that makes Java way less verbose!
Ah, Project Lombok is one of those little gems in the Java Ecosystem. But it's interestingly controversial! Some will love it (as I do), others will hate it! But no matter which camp you land on, you should at least know about it! Project Lombok allows you to, quite easily create your equals/hashcode method, or create a builder pattern for your class, or even generate your getters/setters. All while just adding a simple annotation to your class. How does it do it? (hint. It's preprocessing bytecode magic) But holy cow, when used responsibly, Lombok allows you to write so little code for a ton of cases. So come take a look at why this library is powerful (and learn its benefits, and as importantly, its pitfalls) FOLLOW US on twitter! Where we will be sharing new tech news, and tutorials! We also have been revamping our so go there, take a look, listen to old episodes, or search them! We thank for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/8851046
info_outline
Episode 80. Ah, Maven Archetypes... it's gonna get META
02/03/2019
Episode 80. Ah, Maven Archetypes... it's gonna get META
Nothing like a cold chilly day to stay inside and program some more. Before you start that new project from scratch, let's go over a pretty cool feature of Maven. Maven Archetypes! Learn how to create "project templates" for your new maven project... or better yet, use one of the predefined maven archetypes already out there. We go over how easy is to create your own, and over the flexibility on the things you can do! Are you trying to get all your development teams to start with the same libraries, support, or template? Are you using maven? Then the answer is easy. Create an archetype for them! Come and take a listen as we use Maven to create Maven Template for new Maven projects. FOLLOW US on twitter! Where we will be sharing new tech news, and tutorials! We also have been revamping our so go there, take a look, listen to old episodes, or search them! We thank for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/8499920
info_outline
Episode 79. Here's a present to you! A library that makes you program less (Apache Commons)
01/06/2019
Episode 79. Here's a present to you! A library that makes you program less (Apache Commons)
So for our new episode we decided to give YOU a holiday gift! Apache Commons! We covered one of the libraries that is ubiquotous in anyone who programs Java, but that not many know how robust and complete it is! Do you have to do things like averages, min, max? Or do you have to read CSV files? What about measuring pieces of code with currentTimeMillis? or creating deep copy of Bean objects? Well, these and much more are already supported in the slew of Apache Commons project (and subprojects!). They usually have no transitive dependencies either so they are "ready" for the taking. And because Apache Commons is already used in many open source libraries, chances are that is already in your own project! Making it an easy thing to just start using it. Happy holidays, enjoy this little gift from all of us :). FOLLOW US on twitter! Where we will be sharing new tech news, and tutorials! We also have been revamping our so go there, take a look, listen to old episodes, or search them! We thank for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/8147393
info_outline
Episode 78. OracleCodeOne, the interviews!
11/29/2018
Episode 78. OracleCodeOne, the interviews!
OracleCodeOne just happened... and Freddy and Bob couldn't go... So they recruited the help of Josh Juneau to go out there and capture interviews from anyone who would talk to us! Apparently they did, and we packaged all in this hour-long episode for your enjoyment! Everything from community building, to what's hot in the Java space, to takes from the conference are covered in this series of five minute interviews. So take a listen! It's the next best thing if we couldn't go to OracleCodeOne. And don't forget to follow on twitter! Where we will be sharing new tech news, and tutorials! Lastly, if you haven't visited us in a while, had a new facelift. We made it easier to find episodes, and information about our podcast! We thank for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! We want to thank For participating! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/7727057
info_outline
Episode 77. Sql or NoSql, To Normalize or to Not Normalize... that (STILL) is the question
10/23/2018
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! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/7281122
info_outline
Episode 76. Tick...tock...Time to upgrade to Java 11!
10/04/2018
Episode 76. Tick...tock...Time to upgrade to Java 11!
It's coming! If you have been using Oracle Java 8, you should know that starting on January 2019 we will have to get an oracle license for running Oracle's JDK in production. OR, if you want to keep using Oracle Java (or OpenJDK) for free, and still receive security updates, then you gotta move to 11! In this episode we have no other than itself giving us a tour on what are the less-known changes (and goodies) that are coming when upgrading from 8 to 11. We go through most of the JEPs that usually don't make the news but are actually pretty awesome! So take a listen, and start downloading the new Java 11! We thank DataDogHQ for sponsoring this podcast episode We also thank a.k.a. for joining us in this episode (do follow him!) Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! and and
/episode/index/show/javapubhouse/id/7127488
info_outline
Episode 75. Let's get coding with Kotlin!
08/29/2018
Episode 75. Let's get coding with Kotlin!
While Freddy is travelling from Chicago through the West Coast in a minivan, Bob talked to about the new darling language from the JVM. Kotlin is much more than a novelty now, and with Android support, and some time to "work out the kinks" it has been used Mainstream. Have you been curious on what makes Kotlin interesting, and "fun?". Have you been thinking of taking it for a spin? Well, wait no more! Listen to this episode as Todd takes us through the coolest part of Kotlin! We thank DataDogHQ for sponsoring this podcast episode We also thank for joining us in this episode! Don't forget to SUBSCRIBE to our cool NewsCast! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us!
/episode/index/show/javapubhouse/id/6983242