99 episodes

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.

Java Pub House Freddy Guime & Bob Paulin

    • Technology
    • 4.9 • 41 Ratings

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.

    Episode 97. Hey there Scala 3! Looking good with those new Features!

    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
     

    • 1 hr
    Episode 96. Watching Metrics w/Micrometer and Statsd

    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
     

    • 1 hr 9 min
    Episode 95. Ludicruos speed! Practical GraalVM

    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
    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
     
     

    • 1 hr 8 min
    Episode 94. Oh, put on your hat Dr. Watson, we are sleuthing this Heap Dump

    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!

    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
     
     

    • 1 hr 5 min
    Episode 93. Not your Grandpa's Serialization Part DEUX!

    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


    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!


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

    • 1 hr 10 min
    Episode 92. Not your Grandpa's Serialization!

    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


    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!


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

    • 1 hr 29 min

Customer Reviews

4.9 out of 5
41 Ratings

41 Ratings

Mr Java Guy ,

Gotta love it

Best podcast out there covering java now. Relevant discussions on server side and middle ware. They keep it light and real. Real programmers talking about best practices. Would love to join one of their on location audiences at Java One, Chicago or elsewhere .

Racellosaurus ,

Great!

I really appreciate this podcast. There aren't enough Java podcasts that still update regularly. Thank you!

evangeline Quilantang ,

Really knows his stuff. I learned a lot.

I wish there were more podcasts like this.

Top Podcasts In Technology

Listeners Also Subscribed To