All Episodes
Displaying 1 - 30 of 77 in total
Java Versions Compared: Key Features and Performance Insights
Join us for an enlightening episode of Java Internals Crashcasts, where we compare Java versions from 6 to 22, uncovering essential features and performance insights. ...
Java 17 vs Java 21: Key Differences and New Features
Get ready to dive deep into the evolution of Java with this exciting episode of Java Internals Crashcasts! Sheila and Victor compare Java 17 and Java 21, exploring the...
Java 11 vs Java 17: Key Differences and Advantages
Are you ready to upgrade your Java knowledge? Join Sheila and Victor as they compare Java 11 and Java 17, two significant LTS releases that are shaping the future of J...
Java 9 vs Java 11: Key Differences and Improvements Explained
Join Sheila and Victor in this eye-opening episode of Java Internals Crashcasts, where they delve into the pivotal differences and improvements between Java 9 and Java...
Java 8 vs Java 9: Key Differences Explained
Curious about the key differences between Java 8 and Java 9? Join Sheila and Victor as they break down the most impactful changes in the latest episode of Java Interna...
Mastering Complex Subjects: A Comprehensive Recap
Prepare to master complex Java subjects with our comprehensive recap of the "Advanced Topics" season! In this episode, we explore: Fork/Join Framework: Discover how ...
Understanding the Stack-Walking API: Functions and Applications Explained
Dive into the intricacies of Java's Stack-Walking API and discover its powerful applications in this week's episode of Java Internals Crashcasts! In this episode, we ...
Java Concurrency: Unlocking New Possibilities with CompletableFuture Improvements
Dive into the exciting world of Java concurrency as we explore the powerful enhancements made to CompletableFuture in Java 9 and beyond.In this episode, we explore:Tim...
Deep Dive into VarHandle and Enhanced Atomics: Boosting Java Concurrency
Discover how Java 9+ revolutionizes concurrency with VarHandle and enhanced Atomics, offering up to 30% performance boost for certain operations! In this episode, we ...
Deep Dive into Reactive Libraries: RxJava and Project Reactor for Streamlining Asynchronous Programming
Dive into the world of reactive programming with RxJava and Project Reactor, exploring how these powerful libraries streamline asynchronous programming in Java. In th...
Java's Flow API: Revolutionizing Asynchronous Programming in Java 9 and Beyond
Dive into the world of reactive programming with Java's Flow API, introduced in Java 9, and discover how it's revolutionizing asynchronous programming. In this episod...
Reactive Streams Explained: Understanding the Basics
Dive into the world of Reactive Programming and discover how it's revolutionizing data flow management in modern Java applications. In this episode, we explore: The ...
Deep Dive into HotSpot VM: Understanding Java's Virtual Machine Architecture
Dive into the intricate world of Java's HotSpot VM and uncover the secrets behind its powerful performance optimization techniques. In this episode, we explore: The ...
Just-In-Time Compilation: Boosting Performance Through Real-Time Code Optimization
Dive into the world of Just-In-Time (JIT) compilation and discover how Java achieves lightning-fast performance through real-time code optimization. In this episode, ...
Demystifying Class Loading and Linking in Programming
Dive into the intricate world of JVM internals as we unravel the mysteries of class loading and linking in Java. In this episode, we explore: The lazy loading approa...
Mastering Memory Management: Weak References vs. Memory Leaks in Programming
Dive into the world of Java memory management as we unravel the mysteries of weak references and memory leaks in this enlightening episode of Java Internals Crashcasts...
Mastering Java Performance: Expert Tips for GC Tuning and Monitoring
Dive into the world of Java Garbage Collection optimization with expert insights on tuning and monitoring for peak performance. In this episode, we explore: Understa...
Demystifying Garbage Collection: Serial, Parallel, CMS, and G1 Algorithms Explained
Dive into the world of Java's Garbage Collection algorithms and learn how they impact your application's performance. In this episode, we explore: The fundamentals o...
Unraveling Memory Barriers and Reordering in Computer Systems
Dive into the intricate world of memory barriers and reordering in Java, exploring how these low-level concepts impact concurrent programming. In this episode, we exp...
Understanding the Volatile Keyword: Memory, Optimization, and Concurrency
Dive into the intricacies of Java's volatile keyword and its crucial role in concurrent programming. In this episode, we explore: The true purpose of volatile and ho...
Understanding the Happens-Before Relationship in Concurrent Systems
Dive into the intricate world of Java's Memory Model and unravel the mysteries of the happens-before relationship in concurrent programming. In this episode, we explo...
Mastering the Art of Benchmarking Concurrent Code
Dive into the intricate world of benchmarking concurrent Java code and learn how to accurately measure performance in multi-threaded environments. In this episode, we...
Contention vs. Coherence: The Balancing Act in Communication
Dive into the complex world of concurrent programming as we explore the delicate balance between contention and coherence in Java applications. In this episode, we ex...
Amdahl's Law: The Limits of Parallelism and Why More Processors Aren't Always Better
Dive into the fascinating world of parallel computing and discover why more processors don't always lead to faster performance. In this episode, we explore: Understa...
Mastering the Thread-Safe Singleton: Ensuring Concurrency in Design Patterns
Dive into the world of concurrent design patterns with a focus on mastering the thread-safe Singleton in Java. In this episode, we explore: The Singleton pattern and...
Mastering Read-Write Locks: Essential Concurrency Control in Programming
Unlock the power of concurrent programming with our deep dive into the Read-Write Lock pattern, an essential tool for managing shared resources in Java applications. ...
Understanding the Producer-Consumer Pattern: Mastering Efficient Data Flow
Dive into the world of efficient data flow with the Producer-Consumer pattern, a crucial concept for mastering concurrent programming in Java. In this episode, we exp...
Java Concurrency: Diving Deep into the Power of RecursiveTask and RecursiveAction
Dive into the world of Java concurrency as we explore the powerful RecursiveTask and RecursiveAction classes in the Fork/Join Framework. In this episode, we explore: ...
Mastering ForkJoinPool: Parallel Processing to Boost Java Performance
Dive into the world of advanced Java concurrency with an exploration of ForkJoinPool, a powerful tool for parallel processing. In this episode, we explore: The Fork/...
Mastering Concurrent Collections: A Comprehensive Guide
Wrap up your journey through Java's Concurrent Collections with this comprehensive guide, bringing together essential insights from our entire season. In this episode...