Balkrishna Rawool
IT Chapter Lead at ING Bank NV
Utrecht, The Netherlands
Actions
Balkrishna works as an engineering lead at ING Bank. He is also a frequent speaker at renowned tech conferences. He has passion for continuous learning and genuine desire to sharing knowledge. He enjoys crafting elegant solutions while solving complex challenges. Although he has been working with Java for many years, he finds latest developments in Java quite exciting. In his free time, he enjoys playing chess. The analytical thinking and foresight used in chess is something he finds useful in software development.
Links
Area of Expertise
Topics
Algebraic Data Types + Pattern Matching = Elegant and readable Java code
A talk that starts with a problem and ends up with an elegant implementation using Java's records, sealed types and pattern matching. It's all live coding!
Project Amber is bringing lot of exciting features to Java. Records, sealed types and many pattern matching features are few important ones. Sealed types and records are the mechanisms to create sum- and product-types respectively. These are two important forms of ADT (Algebraic Data Types). Using ADT along with pattern-matching, we can create APIs that are hard to misuse and create programs that are easier to read.
All in all, in the talk we start with a problem statement and a list of requirements and then we create an implementation step-by-step by introducing requirements one by one. While we do that we make use of records, sealed types and pattern matching in Java to create elegant solution with highly readable code.
Continuations: The magic behind virtual threads in Java
Have you wondered how virtual threads in Java are able to provide such high scalability? How is JVM able to switch between so many virtual threads while executing a single platform thread? If you did then this talk is for you.
Continuations is the magic that powers Virtual Threads. A continuation can be viewed as a representation of the current state of the program or it can be viewed as a reference to the rest of the program. It helps us to pause execution of a program (or part thereof) and then resume it later. This ability to pause/resume is a powerful mechanism and is the basis for providing virtual threads.
The talk explains what Continuations are and where they are used. But more importantly, we write our own simple VirtualThread class using the Continuation API provided by JDK. This will give you clear idea about the role of continuations in the nature of virtual threads.
Virtual Threads, Structured Concurrency and Scoped Values: Putting it all together
Project Loom brings lightweight concurrency to Java with Virtual Threads, Structured Concurrency, and Scoped Values. But how do these features work together in a real-world application?
In this talk, we’ll build a Spring Boot application from scratch, progressively incorporating each feature of Project Loom to showcase its full potential. We’ll explore: Virtual Threads – lightweight, high-throughput threads that scale effortlessly. Structured Concurrency – a streamlined approach to managing concurrent tasks as a single unit of work. Scoped Values – a modern alternative to ThreadLocal, designed for virtual threads.
By the end of this session, you’ll have a clear understanding of how to apply Project Loom in your own applications—writing concurrent code that is simpler, more scalable, and easier to maintain.
Structured Concurrency in Java - The What and the Why
This talk introduces Virtual Threads and Structured Concurrency and explains their benefits and shortcomings. It compares Structured Concurrency API with CompletableFuture API by live coding multiple examples with both of these APIs.
Virtual threads are lightweight user threads, enabling Java applications to produce thousand (or even million) times more threads. Also, they are super-efficient as they don't block their 'carrier' threads. These two characteristics of virtual threads enable Structured Concurrency.
With structured concurrency, we can let each business-task be executed by a separate virtual thread and structure these virtual threads in any logical way that we want. It provides us with control structures for managing our virtual threads and simplifies applications that use concurrency.
A big part of the talk is live coding where multiple examples are first implemented with CompletableFuture and then with Structured Concurrency API. For each example, these two implementations are then compared. These examples highlight that CompletableFuture’s reactive-like API relies on callbacks whereas Structured Concurrency puts forward an imperative-like API which is easier to read and reason. Also error handling with Structured Concurrency is more explicit as it uses checked exceptions.
All in all, this talk introduces virtual threads and structured concurrency to the audience and explains why one should seriously consider using it.
Making sense of Vector Databases
Vector databases are quite a hot topic these days. From powering semantic search to recommendation systems and from anomaly detection to clustering, all of this can be achieved with vector databases. But how do they do this? Join this talk to find out.
We start with understanding what a vector is and create a simple example of how vectors can be used. Then we discuss new concepts around vectors and make the examples slightly more complex each time we add a new concept to it. Finally taking the examples to an incredibly amazing level!
All in all, this talk will explain what vectors are, how are they stored, what are embedding models, indexing algorithms and similarity/distance metrics with the help of interesting examples with increasing complexity which provides the talk a flow and keeps you intrigued!
Fantastic Virtual Threads and How to Monitor Them
As part of Project Loom, Virtual Threads have been released in Java 21. They are lightweight user threads, enabling Java applications to produce thousand (or even million) times more threads. But how do we monitor them?
We will discuss the features of Virtual Threads but also look at a few tools that help us monitor Java applications with Virtual Threads: JFR, JMC, VisualVM and jcmd. JFR is a low overhead, event-based tracing framework, built into the Java Runtime. It records various events related to JVM and can export them for later analysis. It captures data points for more than 180 events. JMC is a tool used to visually analyse the JFR exports. VisualVM provides similar monitoring and profiling capabilities. jcmd helps us send diagnostic commands to Java applications.
In order to support virtual threads, this monitoring toolset has also been adapted. JFR has been updated to support 4 more events. We will see how these events are captured for an application with virtual threads and how they can be analysed in JMC. jcmd now supports thread-dump in json format and we will see a live demonstration of that as well.
This talk will introduce the concept of virtual threads to the audience and it will make them aware of the changes coming in the monitoring toolset. Thus, preparing them to be ready when they actually want to use these features.
Structured concurrency in Java - The what and the why
This talk introduces Virtual Threads and Structured Concurrency and explains their benefits and shortcomings. It compares Structured Concurrency API with CompletableFuture API by live coding multiple examples with both of these APIs.
Virtual threads are lightweight user threads, enabling Java applications to produce thousand (or even million) times more threads. Also, they are super-efficient as they don't block their 'carrier' threads. These two characteristics of virtual threads let application developers focus on business requirements rather than managing platform threads (for example, with thread-pools etc.) which enable Structured Concurrency.
With structured concurrency, we can let each business-task be executed by a separate virtual thread and structure these virtual threads in any logical way that we want. It provides us with control structures for managing our virtual threads and simplifies applications that use concurrency.
A big part of the talk is live coding where multiple examples are first implemented with CompletableFuture and then with Structured Concurrency API. For each example, these two implementations are then compared. These examples highlight that CompletableFuture’s reactive-like API relies on callbacks whereas Structured Concurrency puts forward an imperative-like API which is easier to read and reason. Error handling with Structured Concurrency is more explicit as it uses checked exceptions.
All in all, this talk introduces virtual threads and structured concurrency to the audience and explains why one should seriously consider using it.
J-Spring 2025 Sessionize Event
Spring I/O 2025 Sessionize Event
JCON EUROPE 2025 Sessionize Event
Jfokus 2025 Sessionize Event
WeAreDevelopers World Congress 2024 Sessionize Event
Spring I/O 2024 Sessionize Event
JCON EUROPE 2024 Sessionize Event
JCON WORLD 2023 Sessionize Event
Balkrishna Rawool
IT Chapter Lead at ING Bank NV
Utrecht, The Netherlands
Links
Actions
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