107 avsnitt • Längd: 55 min • Oregelbundet
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.
The podcast Java Pub House is created by Freddy Guime & Bob Paulin. The podcast and the artwork on this page are embedded on this page using the public podcast feed (RSS).
Allright, it is time to pull the curtain on all this AI stuff and really learn how it works! On this episode we dive deep into AI, and Neural Networks, refinenements, vector databases (and why we need them) so you can understand the underlying principles of AI and LLM! The field is so vast, intersting and more importantly it's going to be here to stay. So take a listen and keep learning on this new tool we should all be familiar with!
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/
- https://ollama.com/library/llama3.1/blobs/f1cd752815fc - https://onnx.ai/ - https://partee.io/2022/08/11/vector-embeddings/ - https://codelabs.milvus.io/vector-database-101-introduction-to-unstructured-data - https://www.guru99.com/backpropogation-neural-network.html - https://deeplearning4j.konduit.ai/ - https://spring.io/projects/spring-ai - https://medium.com/data-science-at-microsoft/how-large-language-models-work-91c362f5b78f - https://www.v7labs.com/blog/neural-network-architectures-guide
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 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
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
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
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/
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
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
Do you like the episodes? Want more? Help us out! Buy us a beer!
And Follow us! @javapubhouse and @fguime and @bobpaulinAh, 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
Do you like the episodes? Want more? Help us out! Buy us a beer!
And Follow us! @javapubhouse and @fguime and @bobpaulinSo 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
Do you like the episodes? Want more? Help us out! Buy us a beer!
And Follow us! @javapubhouse and @fguime and @bobpaulinJava 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
Do you like the episodes? Want more? Help us out! Buy us a beer!
And Follow us! @javapubhouse and @fguime and @bobpaulinYou 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
Do you like the episodes? Want more? Help us out! Buy us a beer!
And Follow us! @javapubhouse and @fguime and @bobpaulinOne 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
Do you like the episodes? Want more? Help us out! Buy us a beer!
And Follow us! @javapubhouse and @fguime and @bobpaulinIt'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
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
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
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
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
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
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
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
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
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
For participating! Do you like the episodes? Want more? Help us out! Buy us a beer!
And Follow us! @javapubhouse and @fguime and @bobpaulinSo you may have thought about using NoSQL or a Document Database for taking care of you needs. But do you know why that might be not be a good (or a pretty bad idea?). Or you may have a Database that have been running fine, but it seems that you can't work with it anymore? (Is it time to move to NoSql? Would it help?).
We dive into the "Why" would you choose Databases vs NoSQL Data Stores, or when to ditch your MongoDB and actually come back to MySQL. In our current time of "WebScale" and "CloudReady" we get bombarded by choices! (Mongo, Dynamo, MariaDB, ElasticSearch) and while some of the offerings are great, it might not mean that is the Right choice for what we need to store.
So take a listen as we explore normalization and the strength and weaknesses of relational data vs unstructured data. We thank DataDogHQ for sponsoring this podcast episode
Don't forget to SUBSCRIBE to our cool NewsCast! Java Off Heap
Do you like the episodes? Want more? Help us out! Buy us a beer!
And Follow us! @javapubhouse and @fguime and @bobpaulin
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
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
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
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
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
Do you like the episodes? Want more? Help us out! Buy us a beer!
And Follow us! @javapubhouse and @fguime and @bobpaulinEpisode 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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!
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
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!
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
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!
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!)
You worked with them "all the time", whenever you know it or not! Classloaders are the little workers that make sure all the code is there and ready to be executed. Bob revisits this topics and goes into more detail on how the ClassLoading hierarchy works, when to watch out, and how different frameworks (OSGI, and Java EE containers) may be configured to load classes. If you have run into "ClassNotFound" exceptions, this can help you explain why!
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!
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!)
We know how important it is to mind your p's and q's when it comes to garbage (and garbage collection). We go deep into how Generational Garbage Collectors work including reference types (strong, weak, soft, phantom), also how Garbage Collection Pressure (GC Pressure) happens, and how can we create code that is friendly to Generational GCs. In all is a collection of Garbage-related issues that all of us should know. Come and take a listen!
Follow us! @fguime , and @bobpaulin
Subscribe to our new Podcast, JavaPubHouse's Off-Heap! We cover the current tech news related to our famously popular language, and will give our two cents on what it means to us as Java Professionals. So come and subscribe!
Help us pay for bandwidth! (Or a beer!)
Questions, feedback or comments! ([email protected])
Subscribe to our podcast!
Strike 1, Strike 2, and STRIKE 3! We cover the last of the build tools, GRADLE. It's hip, it's cool, it wears a cool leather jacket and rides around on a great motorcycle. The last of the build tools, it has learned from prior mistakes and has combined the best of Ant and Maven into one groovy package. Learn about the last of the build tools, and when to really use it!
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!
Follow Me on Twitter! (@fguime) (thanks!) It's now cold, oh, how I wish for a beer? (Have any?) beer...beer...beeeeeer.....:)
So moving to a more recent build tool we cover probably one of the more popular one. Maven is now incredibly robust, and helps fixing what is known as Jar Hell. Have you ever used two libraries that depended on different versions of a logging framework? Well, Maven makes using tons of libraries incredibly easy. Come and take a listen!
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!
Follow Me on Twitter! (@fguime) (thanks!) It's now cold, oh, how I wish for a beer? (Have any?) beer...beer...beeeeeer.....:)
Episode 46. I've got ANTs in my build!
It's old, but as build tools go you will find apache Ant everywhere. Here we talk on how ant works and explore the build file. While it looks weird, there is nothing to fear! By the end of the episode you will be on your way to tackle any ANT build that have ever been thrown at you!
We thank Codeship for being a Sponsor of the show! Need Continuous Delivery made simple? Check Codeship.com!
Follow Me on Twitter! (@fguime) (thanks!) It's now cold, oh, how I wish for a beer? (Have any?) beer...beer...beeeeeer.....:)
So we are covering what has been in the works for Java EE 8 (JSR-366). This Spec serves as an umbrella for other specs (features) of Java EE.
Some of it is very new, and some of it is already available for all of us to use. Come join me and Bob as we discuss the different things that are going to come down the pike. If you work on the EE space, you gotta listen to keep current! And if you are a J2SE guy like myself, there is still a lot that we can reuse from the JavaEE tools! Follow Me on Twitter! (@fguime) (thanks!) It's now cold, oh, how I wish for a beer? (Have any?) beer...beer...beeeeeer.....:)
This is our yearly pilmigrade to JavaOne, where we get to meet good old friends, create new memories, and best of all, geek out for an entire week on Java! We got to learn about the big things waiting for Java (the Internet of Things), and got to talk about how people are making a difference in Java (With the adopt-a-jsr program). We got to talk to great people like Peter Pilgrim(@peter_pilgrim), Marcel Offermans (@m4rr5), Heather VanCura (@jcp_org), Bruno Souza (@brjavaman), Mattias Karlsson (@matkar) and Geert Bevin (@gbevin). In all, is a great podcast to get a feel of what has been happening at J1! (Oh, and you gotta follow them!)
Follow us! @fguime , and @bobpaulin
Help us pay for bandwidth! (Or a beer!)
Questions, feedback or comments! ([email protected])
Subscribe to our podcast!
So it's all the rage, and things have been getting smaller and slimmer (think your first cell phone compared to today's), well, code is no different! Today we cover a trend on what is considered one of the better ways to scale, yet like everything else there are caveats. Bob is actually going to take us for a spin on creating our own MicroService by using Spring Boot!
Follow us! @fguime , and @bobpaulin
Help us pay for bandwidth! (Or a beer!)
Questions, feedback or comments! ([email protected])
Subscribe to our podcast!
So now we deep dive into what the "Real" advantages of Java 8 are :). The lambdas were just a head-fake (to quote Randy Pausch), the real meat is all the support that was brought because of lambdas, most importantly Streams. Streams are now pervasive in Java 8, and thanks to the way it was implemented is mostly backwards compatible! Oh boy, take a listen to start really tapping into the power of Lambdas and Java 8!
Follow us! @fguime , and @bobpaulin
Help us pay for bandwidth! (Or a beer!)
Questions, feedback or comments! ([email protected])
Subscribe to our podcast!
Lambdas... You have heard about it, it's like those celebrities that are everywhere (Tom Selleck). Well, is time to go and actually meet the great start. In this episode, me (Freddy) and Bob go deep into Lambdas, what they really are (are they magical?) and why would you want to use them. So Join in and let's listen to the most awaited feature of Java 8!
(And yes, the title is a reference to the "Revenge of the Nerds", how appropiate isn't it :)
And we are ramping up again! This is an exciting time to be developing in Java. With the advent of Java 8, lambdas, streams, Jigzaw and the Internet of Things, we are coming back big! In this episode we introduce our co-host Bob Paulin, and offer a glimpse of Java 8, Jigsaw, Streams, and OSGI Standard.
Follow Me on Twitter! (@fguime)
And @Bobpaulin
Ah, beer, it's April, and we just finished taxes ($!) Tweet, Tweet! (https://twitter.com/#!/fguime)
Vote for us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Questions, feedback or comments! [email protected] Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563) Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
So you have programmed for a while, and may even never realized that you have been using them, but there are static methods (which in turn can create static classes), inner classes and static inner classes. Sometimes is hard to understand why or when to use these, but never fear! After listening to this episode you will never get an unexpected static surprise! Follow Me on Twitter! (@fguime) (thanks!) It's now cold, oh, how I wish for a beer? (Have any?) beer...beer...beeeeeer.....:) Tweet, Tweet! (https://twitter.com/#!/fguime)
Vote for us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Questions, feedback or comments! [email protected] Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8& amp;tag=meq-20&linkCode=as2&camp=1789&creative=390957& creativeASIN=1430240563) Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr? cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
So, here's the deal, I went down from Chicago to JavaOne 2013, and took Bob Paulin along. There are sooo many sessions and such great content that it was really hard to know when to start. So we decided to do something cool! We set-up shop in the heart of JavaOne and grab unsuspecting speakers and ask them to spare a couple of minutes to tell us about their sessions (all awesomeness!).
And the good news is that Oracle will make all of the presentations referred in this talk (and much more) available for everyone! Take a listen and prepare to be amazed by the awesome presenters of JavaOne.
- Arun Gupta (@arungupta)
- Bruno Souza (@brjavaman)
- Danno Ferrin (@shemnon)
- Hanz Dockter (@gradleware)
- Charles Nutter (@headius)
- Yoav Landman (@yoavlandman)
It happens all the time, you are working and suddenly you need to database an object. And maybe you have a fancy O/R Mapper or something like that, but we seldomly ask 'do we really need this in a relational format?'. There are actual alternatives (from byte serialization to xml, to, oh, my, NoSql databases). Here we explore the reasons why you may want to skip the Object Relational mapping and concentrate more on ease of development!
Follow Me on Twitter! (@fguime)(thanks!)
Hey it's Freaking HOT outside! beer...beer...beeeeeer.....:) Tweet, Tweet! (https://twitter.com/#!/fguime)
Vote for us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Questions, feedback or comments! [email protected] Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563) Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
So we hear about HyperThreading and how it is sooo cool, well, it is and it isn't. If you are really trying to squeeze performance out of your application HyperThreading might not be what you're looking for. There are so many other things that happens at the CPU level that have so weird names (like Thread Thrashing, 'say whaaaat?'). If you are really serious on squeezing every worthy CPU cycle of your app (or if you're interesting on what really really goes under the hood) take a listen! (ah! and treat me a beer, if you like what you hear!)
Follow Me on Twitter! (@fguime)(thanks!)
Hey it's ALMOST SUMMER! and I would love to get a beer :) Tweet, Tweet! (https://twitter.com/#!/fguime)
Vote for us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Questions, feedback or comments! [email protected] Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563) Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
Have you ever wonder how bit masking work (or what is that?) and why do you need it? Or why a tree structure exists? (or what is breadth first vs depth first), or what are game trees? We put our Computer Science hat and go "depth first" in some fundamental compsci concepts, and, more importantly their utility, ending with Game trees (and they are not only used for games)!
Follow Me on Twitter! (@fguime)(thanks!)
Hey it's SPRING! and I would love to get a beer :) Tweet, Tweet! (https://twitter.com/#!/fguime)
Vote for us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Questions, feedback or comments! [email protected] Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563) Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
This is a presentation I did for the Chicago Java Users Group on the topic of multithreading. There are some solid foundations in here to start tackling multithreading programming. Some of it might've been already been seen in depth from our other episodes, but in all, it has good foundations for anyone that does multithreading programming.
Follow Me on Twitter! (@fguime)(thanks!)
Hey it's winter (and not too many reasons to be outside, so might as well stay home and drink a few!) If you like what you hear, treat me a beer ! :) (It's the Java pub house after all :)
Tweet, Tweet! (https://twitter.com/#!/fguime)
Vote for us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Questions, feedback or comments! [email protected] Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563)
You remember recursion right? that ugly, confusing thing they made you do either on CS-300, or at job interviews. Have you ever wondered how to make it safe and right? and why do we really use recursion? In this episode we go into proper recursion programming (and lose the fear of making it wrong), and understand why stacks get filled with it, and what problems do they really solve (answer, not many).
In addition we talk about the nature of Double objects, vs double the primitive (And why it is so hard to do == comparisons in doubles), plus some little known things about Strings (like interning). In all it has a little bit for everyone, so take a listen!
Follow Me on Twitter! (@fguime)(thanks!)
And if you like what you hear, treat me a beer!
Hey it's winter (and not too many reasons to be outside, so might as well stay home and drink a few!) If you like what you hear, treat me a beer ! :) (It's the Java pub house after all :)
Vote for us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Questions, feedback or comments! [email protected] Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563) Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
Episode 34. New Year's (2013) Resolution! Less bugs and more coverage! ----
Ok, so we all celebrated (but may not remember) the end of the old year and the beginning of a new year! This is a time for starting new things, and trying to be a little better. How about starting by looking at our code and squish some bugs! By using findbugs we can easily test for the 'duh' (and some not so duh) bugs quickly by looking and automatically analyzing our code. After adding Findbugs, we can then add Emma, which will look and measure our unit test code coverage (if you are into such a thing). These two tools are like the Richard Simmons that let us lose the unwanted bug weight in this new year!
If you just joined us, remember to follow me on Twitter! (@fguime)
Beer of the Episode: Anchor Brewing's Liberty Ale
|~|P |~|P |~|P |~|P |~|P |~|P |~|P Anchor Brewing's Liberty Ale |_| |_| |_| |_| |_| |_| |_|
Hey it's winter (and not too many reasons to be outside, so might as well stay home and drink a few!) If you like what you hear, treat me a beer ! :) (It's the Java pub house after all :)
|~|P |~|P |~|P |~|P |~|P |~|P |~|P Anchor Brewing's Liberty Ale |_| |_| |_| |_| |_| |_| |_| Tweet, Tweet! (https://twitter.com/#!/fguime) Findbugs Findbugs Ant (check out the excludeFilter attribute to include/exclude stuff Emma Emma User's Guide (2.3 is what we discussed in the podcast!) Vote for us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Questions, feedback or comments! [email protected] Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563) Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
Episode 33. Does code dream when it hibernates? A quick look on the big things of Hibernate ----
Databases have been around forever! (or at least from the 1970s) and there are many things that try to hook Object Objected Programming with Relational Databases (namely, O/R mappers). Hibernate is the most known O/R mapper and, while effective sometimes it can be confusing. In this podcast we delve on how to understand our misunderstood friend, and finally fix those pesky weird Hibernate exceptions once and for all!
If you just joined us, remember to follow me on Twitter! (@fguime)
and, well, it is Xmas! if you feel generous, and like what you hear, treat me a beer! Tweet, Tweet! (https://twitter.com/#!/fguime) Hibernate Mappings (Annotations) Hibernate Mappings (Annotation Cheat Sheet) Hibernate Mappings (on hbm) Database Normalization Database Normalization Vote for us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Questions, feedback or comments! [email protected] Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563) Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
Shout out to the Chicago Java User's Group! Glad to be part of the Board!
And Shout out to Peter Hendriks and Tim Prijn for their presentation!(https://oracleus.activeevents.com/connect/sessionDetail.ww?SESSION_ID=4153). If interested, click on the 'media' icon on the right side!
With the establishment of Java 7 as the de-facto JRE of Oracle, the clock is ticking down for Java 6! It will be End-Of-Life around February 2013, so we better get going and upgrade! In this episode we cover how to migrate to Java 7, and cover some of the most notable Java 7 features (Networking nuts, your prayers have been answered!) while preparing a path to upgrade. If you have a Java 6 (or 5 or 4) project, this is mandatory listening!
If you just joined us, remember to follow me on Twitter! (@fguime)
and IF you really really really really really really really really really really really really really REALLY like what you hear, treat me a beer!
Tweet, Tweet! (https://twitter.com/#!/fguime) Java 7 Features Compatibility issues (At least glance at this section!) Oracle session: CON4153 - Migrating Real-World Million-Line Code Bases to Java 7: Lessons Learned Vote for us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Questions, feedback or comments! [email protected] Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563) Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
Big shout-out to everyone I met at JavaOne (including some avid podcast listeners!). Thanks for listening and for a great time down at JavaOne! Don't worry, we will be sharing all the stuff I learned on new episodes of the podcast.
It is also our Birthday (We have been airing episodes for a year!)! Happy to celebrate with everyone a year of the podcast (and if you want to celebrate it, treat me a beer! :) ).
With this episode we wrap the concept of generics and bounds (super / extends) and talk about type erasure (and compiler warnings that goes 'Hm, dunno what you're doing but I can't make sure it's right'
And, that...is that!
If you just joined us, remember to follow me on Twitter! (@fguime)
and IF you like what you hear, treat me a beer! Beer of the Episode: Still hung-over from JavaOne's big concert (Go Pearl Jam!) Tweet, Tweet! (https://twitter.com/#!/fguime) Oracle Java Generics (what we're following on this podcast) http://docs.oracle.com/javase/tutorial/java/generics/ Dr Venkat presentation on Generics (Click on the "Media" at the right side for the presentation, a great presentation Agile Developer (Dr Venkat's Must-check website and blog Angelika Langer FAQ on Generics Vote for us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Questions, feedback or comments! [email protected] Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563) Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
Episode 30. I always thought Generics were as good as brand name Erasers (Java Generics part 1) ---- Hi there! Finally back on a (hopefully) standard schedule. I have been moving a house with three kids, two cats, one wife, one dog, and one grandma (they are heavy!, just kidding!) and just found the box with the podcast equipment! we hit the ground running with Generics. What are the benefits (and potential pitfalls) of Generics? Why do we even need them at all? The syntax looks pretty confusing, but with some Jedi Mind tricks one can actually start seeing how they work. If you use Generics (Almost everyone does :)) you should take a listen!
Ah! and if you are going to JavaOne check my t-shirt on the previous post
And if you just joined us, remember to follow me on Twitter! (@fguime)
Also, we are getting close to our first
BIRTHDAY!If you have followed us all year long, or just recently join us, and like what you hear, treat me a beer! Beer of the Episode: No beer, just coffee (it's hard to move a whole house Tweet, Tweet! (https://twitter.com/#!/fguime) Oracle Java Generics (what we're following on this podcast) http://docs.oracle.com/javase/tutorial/java/generics/ Vote for us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Questions, feedback or comments! [email protected] Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563) Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
We go and visit the Primordial Java Concepts. As rules set in stone we explore the concept of multiple inheritance, method and variable scope (including the final keyword), abstract methods and @override. This is good for those starting up their Mad Java SkillZ (We're L33T, u K|\|0w?), or for those who were always curious why the language is this way.
And if you like the podcast, subscribe to my Twitter Feed! http://www.twitter.com/fguime
Beer of the Episode: Leinenkugel's Sunset Wheat |~|P |~|P |~|P |~|P |~|P |~|P |~|P Leinenkugel's Sunset Wheat |_| |_| |_| |_| |_| |_| |_|
It's THE END OF SUMMER! If you like what you hear, DEFINITIVELY, treat me a beer ! :) (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4 |~|P |~|P |~|P |~|P |~|P |~|P |~|P Leinenkugel's Sunset Wheat |_| |_| |_| |_| |_| |_| |_|
Tweet, Tweet!(https://twitter.com/#!/fguime)
Scopeshttp://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html
Override annotationhttp://stackoverflow.com/questions/94361/when-do-you-use-javas-override-annotation-and-why
Abstract Methods and Classeshttp://docs.oracle.com/javase/tutorial/java/IandI/abstract.html
Vote for us in iTunes(http://itunes.apple.com/us/podcast/java-pub-house/id467641329)
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book!(http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563)
Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
Episode 28. Extra! Extra! JMS Delivering Messages to your App! Extra! Extra! ----
Java Message Service (or JMS for short) is a collection of APIs and implementations that allows you to send "messages" across your applcation. But why is it so popular?, and what exactly is it trying to solve (what is a message anyways)? In this episode, we take our bycicle, and trace the delivery route of JMS to figure out the good, and avoid some JMS potholes along the way, making for a smooth message delivery experience!
Beer of the Episode: Leinenkugel's Summer Shandy |~|P |~|P |~|P |~|P |~|P |~|P |~|P Leinenkugel's Summer Shandy |_| |_| |_| |_| |_| |_| |_|
It's SUMMER! If you like what you hear, DEFINITIVELY, treat me a beer ! :) (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
|~|P |~|P |~|P |~|P |~|P |~|P |~|P Leinenkugel's Summer Shandy |_| |_| |_| |_| |_| |_| |_|
Tweet, Tweet!(https://twitter.com/#!/fguime)
Enterprise Integration Patternshttp://www.amazon.com/Enterprise-Integration-Patterns-Designing-Deploying/dp/0321200683
Intro to JMS Conceptshttp://docs.oracle.com/javaee/1.3/jms/tutorial/1_3_1-fcs/doc/basics.html
Apache ActiveMQhttp://activemq.apache.org/
ActiveMQ Language Clients (ActionScript, Ajax, C, C++, C#, .Net, Delphi, Erlang, Flash, Haskell, Javascript, Perl, PHP, Pike, Python, Ruby, Smalltalk, Websockets)http://activemq.apache.org/cross-language-clients.html
RabbitMQ http://www.rabbitmq.com/
JMS Description and Implementationhttp://en.wikipedia.org/wiki/Java_Message_Service
Embed ActiveMQ Broker in codehttp://activemq.apache.org/how-do-i-embed-a-broker-inside-a-connection.html
JMS Tutorialhttp://docs.oracle.com/javaee/1.4/tutorial/doc/JMS.html#wp84181
Vote for us in iTunes(http://itunes.apple.com/us/podcast/java-pub-house/id467641329)
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book!(http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563)
Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
Episode 27. There's a Log File in the folder in the middle of the App ----
(Sing to the children's song There's a hole in the middle of the sea)Logging is part of everyday production debugging life. If you ever had to troubleshoot a production application, the you most likely have looked at log files. These log files can either be a salvation, or an inmense source of frustration. In this podcast we delve into the different logging frameworks, and more importantly, what to log and not to log (and how to log it).
|~|P |~|P |~|P |~|P |~|P |~|P |~|P Beer! (or Mai Tais!) |_| |_| |_| |_| |_| |_| |_|
It's SUMMER! If you like what you hear, DEFINITIVELY, treat me a beer ! :) (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4 |~|P |~|P |~|P |~|P |~|P |~|P |~|P Beer! (or Mai Tais!) |_| |_| |_| |_| |_| |_| |_|
Tweet, Tweet! (https://twitter.com/#!/fguime) Java Logging Frameworkhttp://en.wikipedia.org/wiki/Java_logging_framework
SLF4J (The facade frameworkhttp://www.slf4j.org/
Log4Jhttp://logging.apache.org/log4j/1.2/index.html
Java Logging APIhttp://docs.oracle.com/javase/1.4.2/docs/guide/util/logging/
The linux utilities for windows! (Cygwin)http://www.cygwin.com/
Grep! Grep grepping grep!http://en.wikipedia.org/wiki/Grep
More Grephttp://www.cyberciti.biz/faq/howto-use-grep-command-in-linux-unix/
Vote for us in iTunes(http://itunes.apple.com/us/podcast/java-pub-house/id467641329)
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book!(http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563)
Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
As developers, we have to deal with Exceptions every day (or at least every other day). In this episode we dive a bit on exception (and exception handling), plus we talk about certain behaviors that are not so well-understood (try returning from a finally block, or why exception stack traces sometimes misteriously disappears). A good review for those who already know, and a great primer for those diving into Exceptions, this episode is sure to show some surprises!
(~)P (~)P (~)P (~)P (~)P (Beer) (~)P (~)P (~)P (~)P
It's SUMMER! If you like what you hear, DEFINITIVELY, treat me a beer ! :) (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
(~)P (~)P (~)P (~)P (~)P (Beer) (~)P (~)P (~)P (~)P
Tweet, Tweet! (https://twitter.com/#!/fguime) Try-with-resources constructhttp://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html
Exception Definitionhttp://docs.oracle.com/javase/tutorial/essential/exceptions/definition.html
Checked vs Unchecked Exceptions Debatehttp://www.ibm.com/developerworks/java/library/j-jtp05254/index.html
More Exception Debates from C vs C++, still a useful read. http://www.250bpm.com/blog:4
Vote for us in iTunes(http://itunes.apple.com/us/podcast/java-pub-house/id467641329)
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book!(http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563)
Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
Episode 25. Reflection and vampire classes, and compiling Java from within Java.
We have heard the word "Reflection" thrown around, what does it mean? it is a new Twilight series? is it about Vampires? In all, we shed sunlight into what reflection is (and more importantly why in the world you want to use it). And also cover a technique to compile and load programs within your program. Javascript guys had access to this by doing eval("your program here"), and while Java doesn't have an eval function, there are ways of achieving similar results (and very specific reasons to do this crazy technique. Mostly performance)
It's SUMMER! If you like what you hear, DEFINITIVELY, treat me a beer ! :) (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
Nimbus code to get the dang CacheMode (considered a private variable)
public class ButtonPainter extends AbstractRegionPainter { public ButtonPainter() { Class c = null; PaintContext ctx = new PaintContext(new Insets(0,0,0,0), new Dimension(100,100), false, null, Double.POSITIVE_INFINITY, 2.0 ); try { c = Class.forName("javax.swing.plaf.nimbus.AbstractRegionPainter$PaintContext$CacheMode"); } catch (ClassNotFoundException e) { e.printStackTrace(); } if (c != null) { Object cacheMode = c.getEnumConstants()[2]; // NINE_SQUARE_SCALE for (Field field : ctx.getClass().getDeclaredFields()) { if (c.getName().equals(field.getType().getName())) { // if Field is the CacheMode try { // the following lines would not be necessary for example if // AbstractRegionPainter.cacheMode were protected or public. field.setAccessible(true); // make it accessible so that we can set it field.set(ctx, cacheMode); // set the cachemode // this is equivalent as sayin "ctx.cacheMode = CacheMode.NINE_SQUARE_SCALE" if it were public/protected break; } catch (IllegalAccessException e) { e.printStackTrace(); } } } } } @Override protected PaintContext getPaintContext() { return null; //To change body of implemented methods use File | Settings | File Templates. } @Override protected void doPaint(Graphics2D g, JComponent c, int width, int height, Object[] extendedCacheKeys) { //To change body of implemented methods use File | Settings | File Templates. } }Code to get instance from a source file
public static Object getInstanceForSource(String className, String sourceForRule) { String filename = "tmp/" + className + ".java"; File file = new File(filename); writeFile(filename, sourceForRule); String classPath = System.getProperty("java.class.path"); String[] args = new String[]{ "-classpath", classPath, filename }; StringWriter compilerOutput = new StringWriter(); int status = com.sun.tools.javac.Main.compile(args,new PrintWriter(compilerOutput)); additionalInfo.value = compilerOutput.toString(); switch (status) { case 0: // OK // Make the class file temporary as well File classFile = new File("./tmp/"); try { // Try to access the class and run its main method URLClassLoader loader = new URLClassLoader(new URL[] {classFile.toURI().toURL()}); Class clazz = loader.loadClass(className); return clazz.newInstance(); } catch (Exception ex) { additionalInfo.value = "Exception in main: " + Utilities.exceptionToString(ex)+"\n"+additionalInfo.value; } break; case 1: System.out.println ("Status: Error" +"\n"+additionalInfo.value); break; case 2: System.out.println ("Status: CMDERR" +"\n"+additionalInfo.value); break; case 3: System.out.println ("Status: SYSERR" +"\n"+additionalInfo.value); break; case 4: System.out.println ("Status: ABNORMAL" +"\n"+additionalInfo.value); break; default: System.out.println ("Status: UNKNOWN" +"\n"+additionalInfo.value); break; } return null; } public static void writeFile(String fileName, String content) { Writer writer; File file = new File(fileName); try { writer = new BufferedWriter(new FileWriter(file)); writer.write(content); writer.close(); } catch (IOException e) { System.out.println ("I/O exception "+e); } }Tweet, Tweet!(https://twitter.com/#!/fguime)
Reflection 'trail' http://docs.oracle.com/javase/tutorial/reflect/index.html Create dynamic applications with javax.tools http://www.ibm.com/developerworks/java/library/j-jcomp/index.html URLClassLoaders (loads .class files generatedhttp://docs.oracle.com/javase/6/docs/api/java/net/URLClassLoader.html
Vote for us in iTunes(http://itunes.apple.com/us/podcast/java-pub-house/id467641329)
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book!(http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563)
Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
Designers will come to you, and say "Hm, I think your program is not as user-friendly". And sometimes, when you ask them to elaborate, they seem to follow a hidden and cryptic ritual. They are right, yet, is hard to see how did they come up with those usability suggestion. Alas, behind every usability magician, there is a magic trick! and on this podcast we reveal in plain sight what makes interfaces usable (and quote a lot from Alan Cooper's book). Once you see the trick, you would never be daunted on spotting usability yourself, and making things much more usable before passing them on. Usability magic for all of us!
If you like what you hear, treat me a beer! https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
Twitter, twitter, twitter, twitter!(https://twitter.com/#!/fguime)
The immates are running the asylum (Alan Cooper) http://www.amazon.com/The-Inmates-Are-Running-Asylum/dp/0672316498 Don't make me think http://www.amazon.com/Dont-Make-Me-Think-Usability/dp/0321344758/ref=sr_1_1?s=books&ie=UTF8&qid=1336346454&sr=1-1
Vote for us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329)
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book!(http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563)
Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
It always starts when you do your first Thread.sleep(). Why do I have to check for InterruptedException? is it serious? why do I have to catch it? We start with answering these questions and step down the rabbit hole to discover the inner workings of Wait/Notify (and what the IllegalMonitorStateException really means). If you ever have to work with more than one thread (who doesn't nowadays?) take a listen! You'll be notify()ed of your success!
Twitter, twitter, twitter, twitter!(https://twitter.com/#!/fguime)
Wait/Notify http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Object.html#wait() Concurrency Utilities http://java.sun.com/developer/technicalArticles/J2SE/concurrency/ Thread description from the JVM Specshttp://docs.oracle.com/javase/specs/jvms/se5.0/html/Threads.doc.html#22488
Vote for us in iTunes(http://itunes.apple.com/us/podcast/java-pub-house/id467641329)
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book!(http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563)
Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
Garbage collections are like the engine of a car, we know it works, we know that it powers the car, but not much else, but once it breaks down, we usually don't have a too much of a clue on how to fix it. In this episode we talk about how garbage collections happen, the things it looks for, and more importantly, how it changes your code (there are certain things that you can do to make your code garbage collector friendly). Having this knowledge will help you in the long road on troubleshooting any garbage collection issues (including tuning!), so take a listen to the garbage man!
There is a new band in town! Lambda Expression. Listen to me, and my one-man band in facebook (www.facebook.com/lambdaexpression). And LIKE! (doesn't cost anything!)
Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
Vote for us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Follow us in Twitter!https://twitter.com/#!/fguime
The holy grail of JVM Tuning http://www.oracle.com/technetwork/java/gc-tuning-5-138395.html YourKit Java memory profiler http://www.yourkit.com/ Charlie Hunt Java performance bookhttp://www.amazon.com/Java-Performance-Charlie-Hunt/dp/0137142528
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563)
So you're programming along when suddenly support calls and says that the application just "disappeared", or, the server process is not there anymore, both of them leaving you with a hprof.pid file. You have just witnessed the murder of a Java Virtual Machine, and now is your turn to figure out what happen, and what can we do to prevent such senseless crashes. We cover the main reasons for crashes (most likely not your fault), and best of all, ways around it! So put on your detective hat and let's solve the mysteries surrounding JVM Crashes once and for all!
Hey! if you like what you hear, treat me a beer! (It's the Java pub house after all :) https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=Z8V2ZWV93UMW4
Vote for us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Follow us in Twitter!https://twitter.com/#!/fguime
Most JVM Options http://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.html Troubleshooting tips http://www.oracle.com/technetwork/java/javase/index-137495.html -XX:+ShowMessageBoxOnError http://www.oracle.com/technetwork/java/javase/clopts-139448.html#gbmui .hotspot_compiler to stop compilation of methods More JVM Options (-Xint to disable JIT compiling)
Java 7 recipes book made it to the Java Magazine!http://www.oraclejavamagazine-digital.com/javamagazine/20120304?pg=3#pg10
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563)
In this podcast we turn and talk of that embarassing uncle that every API has (java.util.date), you know, the one that you have to live with because is family, but don't really like that much? We dive into what to avoid when using Date (and Calendar), and the most common pitfalls that we have falled for (1000*60*60*24 anyone?). In all, if you have used date extensively you probably already migrated to JodaTime, but if you are a casual user, then take a listen, just to make sure you are not bitten by the Date traps!
Vote for us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Follow us in Twitter!https://twitter.com/#!/fguime
http://joda-time.sourceforge.net/ (Joda Time) http://www.wolkje.net/2010/01/06/java-date-and-time-api-and-jsr-310/(New Date JSR + what goes under the covers)
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563)
We finish our discussion on the ObjectOutputStream by covering the SerialVersionUID, and then move onto ObjectOutputStream's citadine cousin, XMLEncoder and Decoder (and why would you go and hang out with it). We also make a quick introduction to "The Bean" (Java Beans that is), and discover there isn't too much to it. If you are persisting and/or transmitting, listen to the shocking conclusion (gasp!) of serialization!
Rate us in iTunes (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Follow us in Twitter! https://twitter.com/#!/fguime
http://java.sun.com/developer/technicalArticles/Programming/serialization/ (Serialization/Deserialization) http://docs.oracle.com/javase/1.5.0/docs/guide/serialization/spec/version.html#6678 (Compatible/Incompatible serialization changes) http://java.sun.com/products/jfc/tsc/articles/persistence4/(XMLEncoder/Decoder)
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563)
We all have the need to serialize/deserialize objects (either through the "wire" or to file). In this podcast we go and analyze what exactly happens when we create an ObjectOutputStream and write to it, and more importantly what pitfalls are there to avoid (Out ot memory errors, stale object updates, Not Serializable Exceptions, and toenail fungus!). If you ever considered using ObjectOutput/InputStream, or are actively using in your current projects, take a listen!
https://github.com/eishay/jvm-serializers/wiki/ (Serialization performance comparison for Java, pick one!)
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/gp/product/1430240563/ref=as_li_ss_il?ie=UTF8&tag=meq-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1430240563)
Every developer at one point in time runs into the question, what is beautiful code? Is it code that is expressed concisely? is it code that does a lot in a few lines of code. Well, while we're not the DeveloperPeople's magazine at least there are fundamental concepts that describe code beauty. And while there isn't a consensus (what is beauty anyways), at least there is a baseline for code that is not ugly (hint. It's maintainable). At least a conversation starter, this podcast covers the very minimum that code has to be to not be ugly!
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/Java-7-Recipes-Problem-Solution-Approach/dp/1430240563)
The State pattern is very useful, it's just hard to spot, and at the beginning a little hard to understand. On this podcast we cover the state pattern with a specific example of its use, plus tips on how to spot when to use it (really that's the hardest part of the state pattern). Check this podcast out, and add another pattern to your toolkit!
State Pattern (http://en.wikipedia.org/wiki/State_pattern)
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/Java-7-Recipes-Problem-Solution-Approach/dp/1430240563)
Taking the performance theme, we move into the dark corners of Java Swing and discover that it is not a lame horse at all! Swing is very fast (with support for directX and OpenGL!), but sometimes is hard to get it to perform right. In this podcast we talk about how to make sure of respecting the EDT, offloading from the EDT, we explain how the EventQueue works, and show THE technique for fast GUI performance. If you know what Swing is, tune in! We will dispell Swing's performance myths!
Using Aspects to debug Swing Apps (http://weblogs.java.net/blog/alexfromsun/archive/2006/02/debugging_swing.html) Java Flags for DirectX and OpenGL (http://docs.oracle.com/javase/1.5.0/docs/guide/2d/flags.html) InvokeLater, InvokeAndWait(http://java.sun.com/products/jfc/tsc/articles/threads/threads1.html)
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/Java-7-Recipes-Problem-Solution-Approach/dp/1430240563)
In the second part of optimization, we talk about the tools (or more properly algorithms) that you can use to optimize a piece of code. Ever wonder how to make a piece of code faster? or difference between caching and Divide-and-Conquer? then tune in! You'll become the McGyver of code optimization.
Fork/Join Java 7 (http://docs.oracle.com/javase/tutorial/essential/concurrency/forkjoin.html) Guava (http://code.google.com/p/guava-libraries/) Charlie Hunt's book (http://www.amazon.com/Java-Performance-Charlie-Hunt/dp/0137142528) OpenCL for Java (http://www.jocl.org/) Aparapi(http://developer.amd.com/zones/java/aparapi/Pages/default.aspx)
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/Java-7-Recipes-Problem-Solution-Approach/dp/1430240563)
We all love speed, code speed that is! In this podcast we delve into code optimizations, and what does it mean to optimize for speed. We go over what is the mind-state that you need as you optimize code and offer sneaky shortcuts that allows 10-fold improvement with very little code change (Caching, or pregenerating, or timed-updates). More importantly we go over the process on defining when you have "arrived" at a good optimization point, and hopefully help you optimize what is really important (measuring for performance). If you need to scale up/out and around, listen to this episode!
If you feel you would like to share your optimization experience, go to https://groups.google.com/group/javapubhouse, and post!
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/Java-7-Recipes-Problem-Solution-Approach/dp/1430240563)
In this podcast we talk about the Model-View-Controller pattern (and is prettier cousin, the Model-View-Presenter), and go over how to go about implementing the MVC/MVP Pattern (really, what to instantiate first, and how to wire the whole thing). We also cover the caveats of implementing the MVC, including escaped references in construction, and making the view alway update from the model state. Lastly we talk about where to store view information (such as window size and colors, etc. Hint: not in the model). In all, if you ever needed to touch MVC code, this will help you light the path to awesome interaction! (and ease of unit testing)
http://googletesting.blogspot.com/2009/02/with-all-sport-drug-scandals-of-late.html(Google reference to the MVP pattern)
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/Java-7-Recipes-Problem-Solution-Approach/dp/1430240563)
In this podcast we air our first question/feedback from our listener and dive a little into it (related to Dependency Injection). We also talk about how to create Thread Safe objects (There is the easy way, and the hard way). And at last! we have a Google group where you can add/post comments and open discussions.
Our new Google Groups http://groups.google.com/group/javapubhouse/
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329)
Testing, Testing, 1.2.3! (All about Unit Testing, And Dependency Injection)
For those Unit Testers out there (and those who want to do more unit tests), this podcast is for you! We cover JUnit in general, and explain how to shoe-in unit tests in current (and legacy code). We talked about Dependency Injection (and the Concern of Creation), and Mocking (what it is, and how is it used). In all, if you ever wondered why creating unit tests in your current code is hard, or why are people talking about Dependency Injection (DI), come in, and listen!
Questions, feedback or comments! [email protected]
Subscribe to our podcast! (http://javapubhouse.libsyn.com/rss) ITunes link (http://itunes.apple.com/us/podcast/java-pub-house/id467641329) Java 7 Recipes book! (http://www.amazon.com/Java-7-Recipes-Problem-Solution-Approach/dp/1430240563)
In this episode we talk about the Decorator pattern and how it is applied. We cover a couple of caveats (especially when combined with the Observer pattern) and learn how to not be afraid of its verboseness. In all, it's the season of decorating, so let's decorate!
Questions, feedback or comments! [email protected]
In this episode we go over Aspects (and AspectJ), what really is, and when to use them. It turns out, that there is nothing misterious about them! We also cover how to set-up Aspects for J2SE so you can start using them immediately!
Questions, feedback or comments! [email protected]
VM Parameter -javaagent:dep/aspectjweaver.jar
Example Aspect
@Aspectpublic class OrderAspect { @Before("execution(* *.*(Order))") // must qualify public void anyCall() { System.out.println("Was called from anywhere"); }}Example aop.xml file
Example Folder Structure
src | |-META-INF | |-aop.xmlReferences:
http://www.eclipse.org/aspectj/doc/released/adk15notebook/ataspectj-pcadvice.html
http://www.eclipse.org/aspectj/doc/next/quick5.pdf
http://blog.espenberntsen.net/2010/03/20/aspectj-cheat-sheet/
(Using aspects with annotations) http://stackoverflow.com/questions/2011089/aspectj-pointcut-for-all-methods-of-a-class-with-specific-annotation
In this episode we talk about Threads and Threading, the difference between Daemon and User Threads, and why changing priorities is not for the weak of heart. Also we cover Swing's golden Threading rule (with the Event Dispatching Thread). If you ever typed new Thread(), or if you heard to be careful about Swing and Threading, this episode is for you!
In this week's podcast we talk about Design Patterns (and the Grand Dads of the Software Patterns, the Gang-of-four), and dive into our first design pattern (of many), the Observer pattern. We discussed how to implemented (within Java), and went to describe its use in Java Swing, and why anonymous inner classes for Listeners doesn't create memory leaks (most of the time anyways). In all a great introduction to a first pattern (see what they are all about!)
In this podcast we dive into the age-old producer and consumer problem, talked about the different aspects of it (what does it really solve?), and explain the difference between throughput vs latency. Lastly we discuss the ThreadPoolExecutor and how to fine tune it for your particular project needs!
In this episode we describe the most used collections in the Java framework, and how can they help you out. We also talk about maps (and the importance of immutable keys), and the equals/hashcode contract (why are these anyways? :). Finally we discuss how to safely access these collections/maps from different threads (and cover the check-then-act operations in maps). If you used a map, or ever got a ConcurrentModificationException, this episode is for you!
This episode goes deep into memory in Java, understanding how memory leaks happen (and how to solve them!), also how to design to avoid memory leaks, weak and soft references, and how the Garbage collector works (Eden, Tenured, Perm). This podcast will help everyone that needs to take care of a memory leak!
Kudos to VisualVM and VisualGC!
In this episode of Java pub house, we talk about Deadlocks, livelocks (and other spooky things). Most importantly we talk on how to spot them (using jstack, or visualvm), and how to program defensively against them. We also talk about escaped locks (the source of most deadlocks), and the wait/notify language construct. Finally we describe the unfairness of the lock (locks are not "fair" by default), and why is it so.
On this Episode, we talk about the keyword "volatile", and what does it really mean. Even if you are a multithreading guru, this chapter goes in deep of the different things that volatile protects you from, including L2 caches and code re-ordering. We also cover the use of synchronized, and why, even though is convenient, it might create more headache than it actually solves.
En liten tjänst av I'm With Friends. Finns även på engelska.