Vaibhav Gupta
Backend Engineer | Golang Developer
Tokyo, Japan
Actions
As a backend engineer with 4 years of experience, I have a passion for technology and a strong understanding of development concepts. Currently working as a Backend Engineer in Tokyo, I have developed expertise in Golang, gRPC, and DevOps concepts. With a keen interest in DevOps, I strive to continuously improve my skills and stay up-to-date with the latest industry trends.
As a good communicator, I am adapt to collaborating with cross-functional teams to achieve project goals. Throughout my career, I have demonstrated a track record of delivering high-quality code on time and within budget. I am excited to bring my skills and experience to a new opportunity where I can contribute to the success of the team and drive business growth.
Links
Area of Expertise
After malloc(): Go Memory Management Through a Beginner's Eye
Do you know what actually happens in memory when your Go program runs? Where do your variables live and who decides when they disappear?
Background
When I started writing Go, I thought memory management was something the language just handled for me. Garbage collection was a magic black box. I wrote make(), I allocated structs, I never thought twice.
Then I started building a high-throughput service and things got interesting. Latency spikes I couldn't explain. A heap that kept growing. GC logs that looked like a foreign language. I realised I had been writing Go without understanding one of its most fundamental systems memory.
This talk is a beginner-friendly dive into how Go actually manages memory under the hood. We'll explore how Go decides what lives on the stack versus the heap, how its allocator organises memory using a three-level hierarchy inspired by Google's own TCMalloc, and how the garbage collector finds and frees memory without stopping your entire program.
As someone who has spent the past two years exploring Go's runtime from a beginner's perspective first data race detection, then the goroutine scheduler this talk is the natural third chapter: what happens to the memory those goroutines use.
This session is especially helpful for those who have heard the words "GC pause" or "heap allocation" and nodded along without really knowing what they mean and are ready to finally look inside.
Expected Effect on Audience
Attendees, especially beginners, will leave with:
A clear mental model of stack vs heap and how Go's escape analysis decides which is which
An understanding of Go's three-level memory allocator: mcache, mcentral, and mheap
A visual understanding of the tricolor mark-and-sweep garbage collector and what "stop the world" actually means today
The ability to read GODEBUG=gctrace=1 output and understand what their program's GC is doing
Awareness of the upcoming Green Tea GC in Go 1.25 and why it matters
Curiosity to go deeper into Go's runtime with concrete starting points
This talk completes the bridge from "I write Go" to "I understand what Go does with my memory."
Data Race Detection In Go From Beginners Eye
Do you know what is Data Race in concurrent programming and what is inside it's hood ?
- Background
Recently, I faced a problem in my code a data race issue that caused our service to crash after we mistakenly deployed it without checking for race conditions . I didn't know how to fix and prevent the data race issue at first , so I searched online to learn more about data races and the Go Race Detector. Curiosity led me to explore how to prevent Data Races, and I'm excited to share my story of understanding the inner workings of the Go Data Race Detector.
In the realm of concurrent programming, the occurrence of Data Race conditions can be frequent and challenging to manage. If I put it in simple words , when two or more goroutines access shared memory data concurrently and one goroutine is a write , Data Race conditions may arise, leading to unpredictable failures which we can not detect long after the code has been deployed to production. This session focuses on exploring the Go Race Detector, which is built upon the C/C++ ThreadSanitizer runtime library. Originally designed to identify errors in Google's internal codebase and Chromium, The Race Detector is a powerful and proven tool for detecting data race bugs.
Given that we wanted to write multithreaded programs, how can we protect our systems from the unknown consequences of difficult to track down data race bugs in a manner that is reliable and scalable .
Go Race Detector follows " Pure Happens Before Race Detection" using Vector Clocks so let's understand the concepts.
- Expected effect on audience
This session aims to provide attendees, especially beginners, with a comprehensive understanding of Data Races in concurrent programming. Participants will gain insights into detecting and addressing these issues effectively using the Go Race Detector and also the attendies will learn about the backend technolgy behind Data Race Detector .
After go func(): Goroutines Through a Beginner’s Eye
Have you ever wondered how Goroutines actually run behind the scenes? Why your concurrent Go code works… or sometimes doesn’t?
- Background
When I first started writing concurrent programs in Go, I was amazed by how simple it was to launch a Goroutine just one keyword! But soon I found myself asking:
“What really happens after I write go func()?”
This talk is a beginner-friendly dive into how Go schedules Goroutines using its lightweight runtime scheduler. We’ll explore how Goroutines are mapped onto OS threads, what M:N scheduling really means, how Go handles preemption, and why your code may behave differently than expected under load.
As someone who transitioned from traditional programming models to Go’s concurrency model, I’ll share my personal learning journey including moments of confusion and clarity and how understanding Go’s scheduler helped me write better, more efficient code.
This session is especially helpful for those who have used Goroutines without really knowing what’s under the hood and want to take that first step toward understanding concurrency the Go way.
- Expected Effect on Audience
Attendees especially beginners will leave with:
• A clear mental model of how Go schedules Goroutines
• An understanding of key concepts like G, M, P, and work-stealing
• Tips for writing more predictable and efficient concurrent Go code
• Curiosity to explore Go’s runtime deeper with tools like GODEBUG and scheduler traces
This talk will definitely bridges the gap between “I can write Goroutines” and “I understand how they run.”
Vaibhav Gupta
Backend Engineer | Golang Developer
Tokyo, Japan
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