Java Pub House

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  

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

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/ Sourcegear Vault https://www.sourcegear.com/vault/ 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 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  

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  

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  

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! And Follow us! @javapubhouse and @fguime and @bobpaulin

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

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 Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap AdoptOpenJDK - Binary builds of OpenJDK Red Hat OpenJDK Azul OpenJDK (Zulu) IBM OpenJ9 Oracle OpenJDK Oracle COMMERCIAL JDK Oracle JDK License SDK Man SDKMan for Java Java is STILL Free! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin

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! And Follow us! @javapubhouse and @fguime and @bobpaulin

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! Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap Kubernetes Installing Minikube Kubernetes Concepts Cloud Native Computer Foundation Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin

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! Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap Three Pillars of Observability Slf4J Logback Mapped Diagnostic Context Priority Inversion Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin

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 Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap Reactive Streams Interfaces Spring Webflux Observer Pattern Reactive Performance Comparison Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin  

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 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 GraalVM Official Site Getting Started with GraalVM GraalVM Wikipedia Article Why the Java Community should embrace GraalVM Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin  

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 JavaPubHouse on twitter! Where we will be sharing new tech news, and tutorials! We thank DataDogHQ for sponsoring this podcast episode We also thank OverOps for sponsoring this podcast episode   Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap Java Management Extensions Standard MBeans Basic Introduction to JMX Jolokia (MBean to Rest) Standard MBeans Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin  

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 JavaPubHouse on twitter! Where we will be sharing new tech news, and tutorials! We thank DataDogHQ for sponsoring this podcast episode We also thank OverOps for sponsoring this podcast episode   Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap Netty.io official site Netty.io User Guide (the one we followed in the episode) Jakob Jenkov Tutorial on Netty How to get a Server Response with a Netty Client Introduction to Netty Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin  

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 JavaPubHouse on twitter! Where we will be sharing new tech news, and tutorials! We thank DataDogHQ for sponsoring this podcast episode We also thank OverOps for sponsoring this podcast episode   Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap Spring Boot Actuator Endpoints Microprofile Health Spring Boot Actuator Endpoints Tutorial on Spring Boot Actuator (Including Health) Custom Health Check Spring Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin  

So the internet is all raging about this (not so little) framework that is doing it all. Created with a "cloud-first" mentality, @Micronautfw 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, GraalVM ready, better memory consumption) and see how much "stuff" is in there (the TLDR; A Lot). 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 JavaPubHouse on twitter! Where we will be sharing new tech news, and tutorials! We thank DataDogHQ for sponsoring this podcast episode We also thank OverOps for sponsoring this podcast episode   Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap Micronaut Framework Intro to Micronaut Framework Micronaut Press Release - OCI Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin  

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 JavaPubHouse on twitter! Where we will be sharing new tech news, and tutorials! We also have been revamping our site so go there, take a look, listen to old episodes, or search them! We thank DataDogHQ for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap Project Lombok Intro to Project Lombok Lombok Github Repo Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin  

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 JavaPubHouse on twitter! Where we will be sharing new tech news, and tutorials! We also have been revamping our site so go there, take a look, listen to old episodes, or search them! We thank DataDogHQ for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap Maven Archetypes Archetype Tutorial Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin  

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 JavaPubHouse on twitter! Where we will be sharing new tech news, and tutorials! We also have been revamping our site so go there, take a look, listen to old episodes, or search them! We thank DataDogHQ for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap Apache Commons Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin  

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 JavaPubHouse on twitter! Where we will be sharing new tech news, and tutorials! Lastly, if you haven't visited us in a while, javapubhouse.com had a new facelift. We made it easier to find episodes, and information about our podcast! We thank DataDogHQ for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap We want to thank @alexandrujecan @platypusguy @brjavaman @CesarHgt @ensode @emilyfhjiang @omniprof @mauricedchateau @stuartmarks @ypoirier For participating! Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin

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 Database Normalization SQL vs NoSQL (StackOverflow) Sql Vs NoSql (TheGeekStuff) Max # of Rows MySQL Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin  

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 @DrDeprecator 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 Stuart Marks a.k.a. Dr Deprecator for joining us in this episode (do follow him!) Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap Java is Still Free JDK 9 changes JDK 10 changes JDK 11 changes Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin  

While Freddy is travelling from Chicago through the West Coast in a minivan, Bob talked to Todd Ginsberg 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 Todd Ginsberg for joining us in this episode! Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap Kotling Programming Language Kotlin support for Spring Kotlin and Android Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse  

In this episode we interview Janine Patterson on her talk of "Integration Test Coverage with JaCoCo" and dive into the nuances of Units vs Integration tests. We dive into Gherkin sentences as we use Cucumber, and challenges of integration tests (hint... use Docker). We also dive into the best way to execute these (Spring Runner). In all, if you were interested in upping your integration testing game, this is the one episode to listen to! We thank DataDogHQ for sponsoring this podcast episode We also thank Janine Patterson for joining us in this episode (do follow her!) Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap Janine's Integration Test Coverage with JaCoCo JaCoCo Java Code Coverage + Maven example Cucumber Tutorial Gherkin Language Cucumber Spring Integration Docker Overview Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin  

Episode 73. Spring Boot 2.0 is out! Hear all about it with Greg Turnquist It's new, it's shiny, and is powerful! The new Spring Boot 2.0 framework is out! And we interviewed Spring's own @gregturn to tell us what's new, what's improved and what has changed in 2.0. Diving into a bunch of topics including Reactive APIs, Bob, Greg and I set to explore Spring Boot 2.0 (and why you should upgrade). @gregturn is also the author of Learning Spring Boot 2.0, and he is an authority on many thing Spring. This is an episode you don't want to miss! We thank DataDogHQ for sponsoring this podcast episode We also thank Greg Turnquist for joining us in this episode (do follow him!) Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap Learning Spring Boot 2.0 Designing, Implementing and Using Reactive APIs Spring Boot 2.0 Migration Guide Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin  

We went to one of the best sources to learn what's happening with Var and Java 10, @stuartmarks! Also, what has been (and is being deprecated) on Java 10, and 11. And little inside perspective of having a new java version every six months! Included is a the "convConvenience Factory Methods for Collections" List.of, Set.of, Map.of that @stuartmarks did for Java 9! (and his new contributions for Java 10). And a interesting trick of the non-deterministic order of unmodifiable sets! (A Stuart Marks special!) So come and listen to this episode which contains great tips and tricks directly from one of the contributors to the Java Programming Language API! We thank DataDogHQ for sponsoring this podcast episode We also thank Stuart Marks (Dr Deprecator) for joining us in this episode (do follow him!) Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap Var use guidelines JEP 269: Convenience Factory Methods for Collections Java 9 Convenience Factory Methods for Collections Tutorial Immutable Versus Unmodifiable in JDK 10 Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin

Episode 71. Jigsaw part II, and Java 10 Highlights! So we finally wrapped Jigsaw in this episode (the most prominent feature for Java 9 (and included a small errata from @stuartmarks). But Java is moving at a breakneck speed, and Java 10 was just released a couple of days ago! We couldn't resist covering some of the new and interesting features of the language. So come take a listen to finish up with Jigsaw, and learn what's new for Java 10. We thank DataDogHQ for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap Project Jigsaw Jigsaw Tutorial The new features of Java 10 var on Java 10 Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin  

It was both the most anticipated and (one of the) most controversial features in Java 9. What's the bruhaha all about? What is Jigsaw (or the Java Platform Module System)? What does it bring? Can I use it? And if so, why would I use it? All these questions are answered as we dive into the history of JSR-376 (it has been years in the making). And since Jigsaw is so big, there might be a two-parter for us! So stay tuned! We thank DataDogHQ for sponsoring this podcast episode Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap Project Jigsaw Jigsaw Tutorial Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin

So it's the holidays and now we are winding down the year. Even so, sometimes this is the best time to actually do some performance testing. And there's no better (foss) tool to do so than JMeter! Come and let's dive into how to use JMeter for those stress and performance testing that needs to get done (you're doing stress tests right?) Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap JMeter JMeter Plugins JMeter Quick Guide Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @fguime and @bobpaulin

Episode 68. Clouding it up with Microsoft Service Fabric Clouds are everywhere and are puffy! In this Sponsored Episode, we dive into one of the main prominent cloud providers out there (Microsoft), who is outreaching to us Java Developers! (gasp!). In this episode, the Microsoft Service Fabric team (with @mani_ramaswamy, @HuruliS and Raunak Pandya) takes us in a soup-to-nuts tour on how to get started with Azure's service cloud, including what makes it different from others. Bob and I dive and explore how well would this work for us Java folk (and the answer is "very well") taking questions from how to build and deploy cloud, to what native support is there is for us Java Folk . We thank Microsoft's Service Fabric team for sponsoring this podcast! Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap Azure OpenDev Service Fabric demo repo (from the podcast) Microsoft Service Fabric in 4 minutes Service Fabric SDK & Build Application Service Fabric Docs Service Fabric Course Service Fabric Blog Try Service Fabric (in a Party Cluster!) Microsoft Ignite talks on Cloud Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @javapubhouse and @fguime and @bobpaulin

We sneaked in! Bob and I managed to get into JavaOne (sshhhh....) and made drive-by interviews with some of the luminaries and notable atendees at JavaOne, from Dr. Deprecator @stuartmarks to @reza_rahnman, @edburns, @prpatel, @saturnism, @javaclimber and @shelajev. All in snippets of 10 minute awesomeness talking from deprecation, collections, Eclipse Enterprise for Java, Containerization, and getting Kids involed, it's a great melting pot of topics and opinions! Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap Questions on Deprecation or collections? Eclipse Foundation EE4J Charter 50 Docker Tips and Tricks (as recorded by Ed Burns) Virtual JUG Virtual JUG 24 Conference (Oct 25th) Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @fguime and @bobpaulin and @javapubhouse

So we talked about how to create a rest service (using things like Apache CXF and Spring MVC), but sometimes, we actually need to consume these rest services. Luckily within the Java ecosystem there is a lot of way to skin that cat, and in today's episode we at least cover 4 ways of doing so (including my favorite of the day, Feign). Come take a listen as we dive into Appache HttpComponents, Apache CXF with JaxRS, Spring RestTemplate and Netflix Feign on this fully-loaded episode. Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap Apache HttpComponents Apache CXF JAX-RS Client Spring RestTemplate Netflix Feign Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @fguime and @bobpaulin

What a strange omission, of all the concepts, one that all of us should always have is Caching. We have used it (and most likely we have been burned by it). Come and take a listen on how to correctly (or at least not as incorrectly) think about caching, finding out your "game plan", and using JSR-107, or Hazelcast, or Apache Ignite or Spring. LRU? Time-based? How much memory? Long distribution tails? cacheable keys? All concepts that you should ask before creating/using a cache! Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap Introduction to JCache Guava Caching Apache Ignite Hazelcast Spring JSR-107 annotations Support Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @fguime and @bobpaulin

You heard about it, and you are probably using it already. It is the Spring framework that took over the Web (Spring Boot!). But what makes it so special? and what lurks under the covers? How did it became a thing and what is it really trying to accomplish? Come take a listen with our own Pivotal insider, Michael Minella! (@michaelminella)  Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap Getting Started With Spring Boot Spring Initializr (where you can create the skeleton of your project) Collection of Spring Boot Examples Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @fguime and @bobpaulin

The Java Content Repository (JSR-170 and JSR-283) have been around for a while. For those who don't know it's an actual way of managing content (or assets, or text, or images, or a catalog). Its use can be almost anything, and yet, we didn't know we had it! The best part? It's a JSR so not just that there are different, compatible implementations, but the underlying storage can be changed in a jiffy. Want to store as files in the filesystem, done. How about a Database? also done. How about using something that the cool kids use like Mongo? It Got you covered man! (or Woman!) Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap JCR for Java Apache JackRabbit JCR - The Best of Both Worlds (DZone) Do you like the episodes? Want more? Help us out! Buy us a beer! And Follow us! @fguime and @bobpaulin

So let's talk about one of (if not the) largest, and most interesting framework hosted at Apache. Camel is essentially an implementation of the Enterprise Integration Patterns (EIP) book (which is a mandatory read for the serious dev!). It has so many contributions (and connections) that there is almost no popular system that it can't connect to. In this episode we dive into the reasoning and "spirit" of Camel, to make sense on how to use it. If you ever used Camel, or have run into camel and scratched your head, then definitively take a listen! A Big Thanks to LaunchDarkly for sponsoring our podcast! Feature flagging is easy, feature flag management is hard. What LaunchDarkly has done is essentially take a system like Google or Facebook has made in-house and bring this to the masses. With features like percentage rollouts, audit logging, and flag statuses, teams have complete control over features at scale. When you effectively separate business logic from code, you can build better software, faster without the risk Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap Apache Camel (should be your source for All Things Camel!) Enteprise Integration Patterns Do you like the episodes? Want more? Help us out! Buy us a beer!  

It's not the "cool kid" anymore, but it sure is everywhere! If you ever generated an xml file from a java class (or have created a java class from a definition) you have been using Jaxb! And if you have used for some time, you can see that Jaxb sometimes works, and other times...well. Come take a listen and understand what's happening under the covers! And how you can make JAXB, oh well, "behave!". A Big Thanks to LaunchDarkly for sponsoring our podcast! Feature flagging is easy, feature flag management is hard. What LaunchDarkly has done is essentially take a system like Google or Facebook has made in-house and bring this to the masses. With features like percentage rollouts, audit logging, and flag statuses, teams have complete control over features at scale. When you effectively separate business logic from code, you can build better software, faster without the risk Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap JaxB info Intro to JaxB Hello world Jaxb style! Customizing Bindings Do you like the episodes? Want more? Help us out! Buy us a beer!

So you have heard about it, and probably ran into it already. Docker is a super cool tech that let us create / manage and deploy applications (It is really what would come out if Devs and Ops decided to have a kid). Come hear how you can too master the art of Docker, and more importantly why is it so "accepted" and revered. A Big Thanks to LaunchDarkly for sponsoring our podcast! Feature flagging is easy, feature flag management is hard. What LaunchDarkly has done is essentially take a system like Google or Facebook has made in-house and bring this to the masses. With features like percentage rollouts, audit logging, and flag statuses, teams have complete control over features at scale. When you effectively separate business logic from code, you can build better software, faster without the risk Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap Docker Intro Getting Started w/Docker Linux Kernel space vs User Space Do you like the episodes? Want more? Help us out! Buy us a beer!

Yeah, today Streams might seem like old news, but you know what? It's worth revisiting and discovering what we didn't know from before. In this episode, Bob, Michael, and I come back to revisit Streams and share what was good, bad (and evil) of them. Including some great trivia on default implementations (a weird Java 8 feature). If you have started to use streams, but not sure if they make sense, or if you are about to dive into them, take a listen! The perspective is great! Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap Processing Data with Java SE 8 Streams Java 8 Streams Cheat Sheet Venkat and Streams Default Methods Do you like the episodes? Want more? Help us out! Buy us a beer!

So REST is just a webpage that returns JSON right? Well, no! Apparently I've been doing REST All wrong! It's much more rich and complete than what we are led to believe. Come join us with Bob Paulin as we talk what the real deal on REST is (and how to implement REST endpoints in Java)  Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap Roy Thomas Fielding on Rest JAX-RS Spec JAX-RS Implementations for Java Do you like the episodes? Want more? Help us out! Buy us a beer!

Threadlocal is great! It can help you get out of sticky situations, and give you a great boost of performance and/or isolation. But with great tools comes great responsibility. Threadlocal can also be misused, and create memory leaks, or object corruption, and unknown sharing. So if you ever had seen one and never quite got what it does, or even if you were consider using one. Take a listen! And steer the people in the right way for the use of Threadlocal. Also, Thanks Michael for pointing the issue with episode 55 and rebasing! Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap https://docs.oracle.com/javase/7/docs/api/java/lang/ThreadLocal.html http://tutorials.jenkov.com/java-concurrency/threadlocal.html http://jsr166-concurrency.10961.n7.nabble.com/Threadlocals-and-memory-leaks-in-J2EE-td3960.html Do you like the episodes? Want more? Help us out! Buy us a beer!

So you heard about sun.misc.unsafe. Even if you are in certain circles you might have heard about that it was (almost) removed from Java 9. And if you were really paying attention you would've heard the cries of every major Java Framework to the news. While it didn't happen (Unsafe is still in Java 9, and possibly in Java 10+), we should dive into why is it so attractive, and creates such a divided opinion (JVM implementers want it gone. Performance nuts want it in) Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap sun.misc.unsafe explained Do you like the episodes? Want more? Help us out! Buy us a beer!

Source Control, it's one of those tools that professionally we MUST need to master, and even if you are a hobbyist is a great thing to learn. In today's episode we cover one of the "hottest" source control system out there (Git). Created by Linus Torvals, it's quirky and weird when coming from Subversion (or gosh forbid, Visual Sourcesafe). But not to worry, if you have always been wondering about Git, and how it really works (or more importantly, how to use it), this is the episode to listen to! Don't forget to SUBSCRIBE to our cool new NewsCast! Java Off Heap Do you like the episodes? Want more? Help us out! Buy us a beer!

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?

You always hear about it, Spring MVC this, Spring MVC that, wondering what really happens under the hood. Well, wonder no more! In this episode we break up and analyze Spring MVC to the core, so that you know exactly what happens! Taking it from the last episode (JavaEE), we push forward to how modern software development happens today! Don't forget to SUBSCRIBE to our NewsCast Java Off Heap We thank Codeship for being a Sponsor of the show! Need Continuous Delivery made simple? Check Codeship.com! And use code JAVAPUB20 for a 20% discount! Now with Organizations! We also thank Hazelcast for sponsoring the show! If you need a distributed implementation of the Java collections, no need to look further than Hazelcast! Spring MVC Step by Step Web MVC Framework Spring MVC Tutorial Follow Me on Twitter! (@fguime) (thanks!) How about a summer shandy?

So let's try to understand this Java EE World, shall we? Going from the very basic request, we unravel the magic that a Java EE Container creates. When we see the tricks behind the wall, it suddenly looks a lot like SE with some sprinkled web stuff on top! If you want to really know what happens every time you go to a browser and type http://, you should hear this podcast! Don't forget to SUBSCRIBE to our NewsCast Java Off Heap   We thank Codeship for being a Sponsor of the show! Need Continuous Delivery made simple? Check Codeship.com! And use code JAVAPUB20 for a 20% discount!   We also thank Hazelcast for sponsoring the show! If you need a distributed implementation of the Java collections, no need to look further than Hazelcast! Links Java EE Containers HTTP Servlets request/response Java EE Implementations Follow Me on Twitter! (@fguime) (thanks!) Ok, so now is allergy season, and I heard beer with honey is good for you. Or better yet, beer made of honey (Mead!)

If you stepped into the Java EE world, you must have run into Spring. There is Spring XD, Spring Batch, Spring everything-under-the-sun. Sometimes we keep using it as a rut, but today we take a look at Spring (and Spring Core) with a new set of eyes and learn the real reason for Spring Beans. A great introduction if you never been exposed to Spring, and a even better reminder of why Spring Beans exists in the first place! Don't forget to SUBSCRIBE to our NewsCast Java Off Heap We thank Codeship for being a Sponsor of the show! Need Continuous Delivery made simple? Check Codeship.com! And use code JAVAPUB20 for a 20% discount! JavaPubHouse Spring Beans Example The IoC Container in Spring Spring Bean Lifecycle Follow Me on Twitter! (@fguime) (thanks!) Ok, so now is allergy season, and I heard beer with honey is good for you. Or better yet, beer made of honey (Mead!)