Bazlur Rahman
Java Champion 🏆 Empowering Developers through Speaking 🗣️ Writing ✍️ Mentoring 🤝 & Community Building 🌍 Published Author 📖 Contributing Editor at InfoQ and Foojay.IO
Toronto, Canada
Actions
A N M Bazlur Rahman is a Software Engineer with over a decade of specialized experience in Java and related technologies. His expertise has been formally recognized through the prestigious title of Java Champion. Beyond his professional commitments, Mr. Rahman is deeply involved in community outreach and education. He is the founder and current moderator of the Java User Group in Bangladesh, where he has organized educational meetups and conferences since 2013.
In the past two years, Mr. Rahman has been an active speaker at various international conferences and Java user groups. His talks have often focused on specialized topics such as concurrency and virtual threads. In addition to his community work, Mr. Rahman also serves as an editor for Java Queue at InfoQ and Foojay.io, both of which are leading platforms for technology content. Notably, he has authored five books on the Java programming language in Bengali, three of which have become best sellers in Bangladesh.
He has published a new book with O'Reilly titled "Modern Concurrency in Java."
https://learning.oreilly.com/library/view/modern-concurrency-in/9781098165406/
Badges
Area of Expertise
Topics
Old Dog, New Tricks: The Java 25 Reinvention
Java 25 isn’t just playing catch-up with newer languages; it’s reinventing itself by integrating some of the best ideas. Inspired by Kotlin’s succinct data classes and Scala’s pattern matching, Java now has records and enhanced pattern matching to make code cleaner and more expressive. Taking cues from Go’s lightweight concurrency, it introduces virtual threads and structured concurrency for massively scalable, simpler parallel code. And thanks to a bit of Rust’s influence on safety, the new Foreign Function & Memory API makes calling native libraries both high-performance and safe.
No fluff, no marketing – just real code and use-cases: we’ll look at how these features reduce boilerplate, boost performance, and tame concurrency headaches in everyday Java development. By the end, you’ll see how an “old” language can learn new tricks that will make your life easier as a Java developer.
A tale of two cities: blocking code vs. non-blocking code
We don’t have to exert much mental effort when writing blocking code, but this has drawbacks. Non-blocking code, on the other hand, could be used to increase application throughput. This is why non-blocking code is recommended in many scenarios. Over the last two decades, many approaches have been introduced to writing code that does not block.
In this session, we will look into those options that are available to us. To begin, I’ll go over the evolution of the Java concurrency model since its inception with the vanilla thread. Then I will introduce Future/Callable, and CompletableFuture, briefly go over reactive programming, and finally conclude with the Project Loom that was added in Java 19.
Virtual Threads: Ushering in a New Era of Concurrency
Project Loom introduces virtual threads, lightweight threads that aim to dramatically reduce the effort of writing, maintaining, and monitoring high-throughput concurrent applications on the Java platform. We will begin with an overview of virtual threads and their evolution through JEPs 425, 436, and 444, discussing their design goals and integration into the JDK. We will then dive into practical examples, demonstrating how to create and manage virtual threads using the new Executors API, and showcasing their compatibility with existing Java code. Then this talk will explore a bit on how virtual threads are implemented,. how they solve our modern problems, and what, if any, shortcomings there may be.
From Blocking to Breakthrough: A Tale of Java's Scalability Journey
Writing blocking code might seem effortless, but it comes at the cost of application responsiveness and scalability. Non-blocking code offers a path to greater efficiency and throughput. In this session, we'll chart the evolution of Java's concurrency model, exploring the trade-offs and techniques that make non-blocking development possible.
We'll start with the classic thread model, delve into Futures/Callables and CompletableFutures, touch on the power of reactive programming, and culminate with the game-changing potential of Project Loom.
Come away equipped to make informed choices about when and how to harness non-blocking code for your Java projects.
Is Java Pattern Matching Finally Good Enough?
Ready to eliminate tangled if-else chains and outdated type checks? Java's newest feature, pattern-matching, promises a cleaner, more elegant approach to coding.
However, how does it compare with other JVM languages, such as Kotlin and Scala, which have had this feature for a long time? This session delves deep into Java's pattern-matching evolution, placing it side-by-side with Kotlin and Scala for a direct comparison. Explore where Java's new features excel, where they might still fall short, and whether it's time to refactor your projects confidently.
Attendees will gain practical insights through live code demonstrations, showcasing real-world scenarios where pattern matching can simplify and streamline codebases. The session offers clear, practical takeaways, whether you're a Java loyalist or curious about Kotlin and Scala. Walk away with a good grasp of pattern matching and its potential in day-to-day coding.
Java + LLMs: A hands-on guide to building LLM Apps in Java with Jakarta
AI is revolutionizing the software landscape. However, for many Java developers, integrating these powerful AI tools into existing enterprise applications or a new one can feel daunting. In this hands-on session, we'll demystify the process and show you how to build LLM-powered features directly into your Java codebase.
Using JakartaEE and the LangChain4j library, we'll dive deep into Retrieval Augmented Generation (RAG), a cutting-edge technique that combines the vast knowledge of LLMs with the precision of your own data. We'll explore how to create both few-shot and zero-shot RAG models, and then add practical features like summarization and similarity search, backed by an Embedding database.
Through a live coding demo, we’ll walk you through constructing an AI-powered online store backend and provide practical insights into the architecture and code.
Whether you're familiar with AI or just getting started, this session will give you the confidence and skills to harness the potential of LLMs in your Java projects.
Mastering Modern Concurrency in Java - A Comprehensive Deep Dive with Virtual Threads
Traditional methods of handling multiple tasks in Java have limitations, such as resource-heavy threads and complex code. These limitations can hinder performance and development speed in today's world, where fast, efficient applications are a must.
This session aims to introduce and demystify the latest Java 21 concurrency features—Virtual Threads, Structured Concurrency, Scoped Values. These tools can help you build faster, more efficient applications while keeping your code clean and manageable.
We'll deep-dive into each of these four topics through a blend of theory and practical code examples. You'll learn how to:
- Utilize Virtual Threads for efficient multitasking
- Implement Structured Concurrency for more readable and maintainable code
- Leverage Scoped Values for smarter data sharing
- Understand the continued relevance of Reactive Java in this new landscape
Whether you're a seasoned developer or an architect, this session will equip you with the knowledge and skills to implement these modern features effectively.
Join me and take the first step towards mastering the future of Java concurrency!
Breaking Java Stereotypes: It's Not Your Dad's Language Anymore
Discover the transformed Java programming language that defies stereotypes and embraces modernity. Explore its evolution with features like Records, Pattern Matching, Sealed Classes, Functional Programming, Virtual Threads, Structured Concurrency, String Templates, Flexible Main Method, Text Blocks, and Data-Oriented Programming. Learn how these advancements empower developers to write concise, expressive, and efficient code, dispelling the notion that Java is a legacy language. Join us to break the Java stereotypes and embrace the exciting possibilities of this dynamic and forward-thinking language.
Breaking Barriers: Virtual Threads Transforming Java’s Framework Landscape
In the evolving landscape of concurrent programming in Java, the introduction of virtual threads, part of Project Loom, marks a significant shift. This talk explores the practical applications and performance implications of virtual threads in popular Java frameworks like Spring Boot, Quarkus, Vert.x, Micronaut, and Helidon. By comparing and contrasting their integration and optimization with virtual threads, the session will provide attendees with a comprehensive understanding of leveraging this technology in different frameworks to achieve scalable and efficient applications.
Microsoft JDConf 2026 Sessionize Event Upcoming
Devnexus 2026 Sessionize Event Upcoming
JChampions Conference 2026 Sessionize Event
Microsoft JDConf 2025 Sessionize Event
Devnexus 2025 Sessionize Event
JChampions Conference 2025 Sessionize Event
Copenhagen Developers Festival 2024 Sessionize Event
JCON EUROPE 2024 Sessionize Event
JChampions Conference 2024 Sessionize Event
JCON WORLD 2023 Sessionize Event
JCON EUROPE 2023 Sessionize Event
Devnexus 2023 Sessionize Event
JChampions Conference 2023 Sessionize Event
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top