title: "Go Reflection Deep Dive: Type, Value, and Practical Patterns" summary: "A comprehensive guide to Go's reflect package, covering Type introspection, Value manipulation, and creating objects dynamically." date: 2026-02-11 tags: ["Go", "Reflection", "reflect", "Type", "Value", "Golang"] featured: false

Go Reflection Deep Dive: Type, Value, and Practical Patterns

Reflection gives Go programs the ability to inspect and manipulate types and values at runtime. It is one of the most powerful features in the language, but that power comes at a cost. Before reaching for the reflect package, keep two things in mind:

1. Code that uses reflection is hard to read, hard to maintain, and prone to runtime panics in production
2. Performance is poor, typically one to two orders of magnitude slower than equivalent non reflective code

With that said, reflection is indispensable in certain scenarios such as serialization, ORMs, and generic frameworks. The two most important concepts in Go's reflection are Type and Value. Type is used to obtain type related information (such as the length of a Slice, the fields of a struct, or the number of parameters of a function). Value is used to get and modify the values of the original data (such as modifying elements in a slice or map, or modifying struct fields). The conversion between these and Go's primitive data types (such as int, float, map, struct, etc.) is illustrated in the diagram below:

All the methods shown in the diagram above will be covered below. We'll start with Type, then cover Value.

Throughout this post, the examples use the following types:

type People interface {
	Think()
}

type User struct {
	Id     int     `json:"id"`
	Name   string  `json:"name"`
	addr   string  // unexported field
	Weight float64 `json:"weight"`
	Height float64 `json:"height"`
}

func (u *User) BMI() float32 {
	return float32(u.Weight / (u.Height * u.Height))
}

func (u User) Think() {
	fmt.Printf("%s is thinking\n", u.Name)
}

reflect.Type

How to Get a Type

Use TypeOf() to get a Type:

typeI := reflect.TypeOf(1)
typeS := reflect.TypeOf("hello")
fmt.Println(typeI)  // int
fmt.Println(typeS)  // string

typeUser := reflect.TypeOf(&User{})
fmt.Println(typeUser)                // *User
fmt.Println(typeUser.Kind())         // ptr
fmt.Println(typeUser.Elem().Kind())  // struct

Converting Pointer Type to Non Pointer Type

typeUser := reflect.TypeOf(&User{})
typeUser2 := reflect.TypeOf(User{})
assert.IsEqual(typeUser.Elem(), typeUser2)

Getting Struct Field Information

typeUser := reflect.TypeOf(User{})  // Must use struct's Type, not the pointer's Type
fieldNum := typeUser.NumField()     // Number of fields
for i := 0; i < fieldNum; i++ {
	field := typeUser.Field(i)
	fmt.Printf("%d %s offset %d anonymous %t type %s exported %t json tag %s\n", i,
		field.Name,            // Field name
		field.Offset,          // Memory offset relative to the struct's base address; string type occupies 16 bytes
		field.Anonymous,       // Whether it is an anonymous (embedded) field
		field.Type,            // Data type, of reflect.Type
		field.IsExported(),    // Whether it is visible outside the package (i.e., starts with an uppercase letter)
		field.Tag.Get("json")) // Get the tag defined inside `` after the field
}
fmt.Println()

// You can get a Field by name using FieldByName
if nameField, ok := typeUser.FieldByName("Name"); ok {
	fmt.Printf("Name is exported %t\n", nameField.IsExported())
}
// You can also get a Field by index using FieldByIndex
thirdField := typeUser.FieldByIndex([]int{2})  // The parameter is a slice, because structs can be nested
fmt.Printf("third field name %s\n", thirdField.Name)

Getting Struct Method Information

typeUser := reflect.TypeOf(User{})
methodNum := typeUser.NumMethod()  // Number of methods. Methods with pointer receivers are NOT included
for i := 0; i < methodNum; i++ {
	method := typeUser.Method(i)
	fmt.Printf("method name:%s ,type:%s, exported:%t\n", method.Name, method.Type, method.IsExported())
}
fmt.Println()

typeUser2 := reflect.TypeOf(&User{})
methodNum = typeUser2.NumMethod()  // Number of methods. Methods with BOTH pointer and value receivers are included, meaning methods implemented by the value are also implemented by the pointer (but not vice versa)
for i := 0; i < methodNum; i++ {
	method := typeUser2.Method(i)
	fmt.Printf("method name:%s ,type:%s, exported:%t\n", method.Name, method.Type, method.IsExported())
}

Getting Function Information

func Add(a, b int) int {
	return a + b
}

typeFunc := reflect.TypeOf(Add)  // Get the function's type
fmt.Printf("is function type %t\n", typeFunc.Kind() == reflect.Func)
argInNum := typeFunc.NumIn()    // Number of input parameters
argOutNum := typeFunc.NumOut()  // Number of output parameters
for i := 0; i < argInNum; i++ {
	argTyp := typeFunc.In(i)
	fmt.Printf("Input parameter %d has type %s\n", i, argTyp)
}
for i := 0; i < argOutNum; i++ {
	argTyp := typeFunc.Out(i)
	fmt.Printf("Output parameter %d has type %s\n", i, argTyp)
}

Checking if a Type Implements an Interface

// Get the interface type via reflect.TypeOf((*<interface>)(nil)).Elem(). Since People is an interface and cannot be instantiated, we cast nil to *People
typeOfPeople := reflect.TypeOf((*People)(nil)).Elem()
fmt.Printf("typeOfPeople kind is interface %t\n", typeOfPeople.Kind() == reflect.Interface)
t1 := reflect.TypeOf(User{})
t2 := reflect.TypeOf(&User{})
// If the value type implements the interface, then the pointer type also implements it; the reverse is not true
fmt.Printf("t1 implements People interface %t\n", t1.Implements(typeOfPeople))

reflect.Value

How to Get a Value

Use ValueOf() to get a Value:

iValue := reflect.ValueOf(1)
sValue := reflect.ValueOf("hello")
userPtrValue := reflect.ValueOf(&User{
	Id:     7,
	Name:   "John",
	Weight: 65,
	Height: 1.68,
})
fmt.Println(iValue)        // 1
fmt.Println(sValue)        // hello
fmt.Println(userPtrValue)  // &{7 John  65 1.68}

Converting Value to Type

iType := iValue.Type()
sType := sValue.Type()
userType := userPtrValue.Type()
// Calling Kind() on both the Type and the corresponding Value yields the same result
fmt.Println(iType.Kind() == reflect.Int, iValue.Kind() == reflect.Int, iType.Kind() == iValue.Kind())
fmt.Println(sType.Kind() == reflect.String, sValue.Kind() == reflect.String, sType.Kind() == sValue.Kind())
fmt.Println(userType.Kind() == reflect.Ptr, userPtrValue.Kind() == reflect.Ptr, userType.Kind() == userPtrValue.Kind())

Converting Between Pointer Value and Non Pointer Value

userValue := userPtrValue.Elem()                     // Elem() converts a pointer Value to a non pointer Value
fmt.Println(userValue.Kind(), userPtrValue.Kind())   // struct ptr
userPtrValue3 := userValue.Addr()                    // Addr() converts a non pointer Value to a pointer Value
fmt.Println(userValue.Kind(), userPtrValue3.Kind())  // struct ptr

Getting the Original Data from a Value

Use the Interface() function to convert a Value to interface, then use a type assertion to convert from interface to the original data type. Alternatively, call Int(), String(), etc. directly on the Value for a one step conversion.

fmt.Printf("origin value iValue is %d %d\n", iValue.Interface().(int), iValue.Int())
fmt.Printf("origin value sValue is %s %s\n", sValue.Interface().(string), sValue.String())
user := userValue.Interface().(User)
fmt.Printf("id=%d name=%s weight=%.2f height=%.2f\n", user.Id, user.Name, user.Weight, user.Height)
user2 := userPtrValue.Interface().(*User)
fmt.Printf("id=%d name=%s weight=%.2f height=%.2f\n", user2.Id, user2.Name, user2.Weight, user2.Height)

Checking for Empty/Invalid Values

var i interface{}  // Interface not pointing to a concrete value
v := reflect.ValueOf(i)
fmt.Printf("v holds a value: %t, type of v is Invalid: %t\n", v.IsValid(), v.Kind() == reflect.Invalid)

var user *User = nil
v = reflect.ValueOf(user)  // Value points to nil
if v.IsValid() {
	fmt.Printf("the value held by v is nil: %t\n", v.IsNil())  // Call IsNil() only after confirming IsValid(), otherwise it will panic
}

var u User  // Only declared, all fields are zero values
v = reflect.ValueOf(u)
if v.IsValid() {
	fmt.Printf("the value held by v is the zero value of its type: %t\n", v.IsZero())  // Call IsZero() only after confirming IsValid(), otherwise it will panic
}

Modifying Original Data via Value

var i int = 10
var s string = "hello"
user := User{
	Id:     7,
	Name:   "John",
	Weight: 65.5,
	Height: 1.68,
}

valueI := reflect.ValueOf(&i)  // Since all function arguments in Go are passed by value, you must pass a pointer to modify the original value
valueS := reflect.ValueOf(&s)
valueUser := reflect.ValueOf(&user)
valueI.Elem().SetInt(8)  // Since valueI corresponds to a pointer, use Elem() to get the object the pointer points to
valueS.Elem().SetString("golang")
valueUser.Elem().FieldByName("Weight").SetFloat(68.0)  // FieldByName() returns a struct field by name

Important: to modify the original data, you must pass a pointer to ValueOf. However, you cannot call Set or FieldByName on a pointer Value, so you must first convert it to a non pointer Value using Elem().

Unexported fields cannot be modified via reflection.

addrValue := valueUser.Elem().FieldByName("addr")
if addrValue.CanSet() {
	addrValue.SetString("New York")
} else {
	fmt.Println("addr is an unexported field and cannot be Set")  // Fields starting with a lowercase letter are effectively private
}

Modifying a Slice via Value

users := make([]*User, 1, 5)  // len=1, cap=5
users[0] = &User{
	Id:     7,
	Name:   "John",
	Weight: 65.5,
	Height: 1.68,
}

sliceValue := reflect.ValueOf(&users)  // Pass the address of users since we intend to modify it via Value
if sliceValue.Elem().Len() > 0 {       // Get the length of the slice
	sliceValue.Elem().Index(0).Elem().FieldByName("Name").SetString("Mike")
	fmt.Printf("1st user name change to %s\n", users[0].Name)
}

You can even modify the slice's cap. The new cap must be between the original len and cap, meaning you can only reduce the cap.

sliceValue.Elem().SetCap(3)

By increasing the len, you can effectively append elements to the slice.

sliceValue.Elem().SetLen(2)
// Use reflect.Value's Set() function to modify the underlying original data
sliceValue.Elem().Index(1).Set(reflect.ValueOf(&User{
	Id:     8,
	Name:   "Sarah",
	Weight: 80,
	Height: 180,
}))
fmt.Printf("2nd user name %s\n", users[1].Name)

Modifying a Map

Value.SetMapIndex(): adds a key value pair to the map

Value.MapIndex(): retrieves the value corresponding to a key from the map

u1 := &User{
	Id:     7,
	Name:   "John",
	Weight: 65.5,
	Height: 1.68,
}
u2 := &User{
	Id:     8,
	Name:   "Tom",
	Weight: 65.5,
	Height: 1.68,
}
userMap := make(map[int]*User, 5)
userMap[u1.Id] = u1

mapValue := reflect.ValueOf(&userMap)                                                         // Pass the address of userMap since we intend to modify it via Value
mapValue.Elem().SetMapIndex(reflect.ValueOf(u2.Id), reflect.ValueOf(u2))                      // SetMapIndex adds a key value pair to the map
mapValue.Elem().MapIndex(reflect.ValueOf(u1.Id)).Elem().FieldByName("Name").SetString("Mike")  // MapIndex retrieves the value for a key from the map
for k, user := range userMap {
	fmt.Printf("key %d name %s\n", k, user.Name)
}

Calling Functions

valueFunc := reflect.ValueOf(Add)  // A function is also a data type
typeFunc := reflect.TypeOf(Add)
argNum := typeFunc.NumIn()             // Number of input parameters
args := make([]reflect.Value, argNum)  // Prepare the function's input arguments
for i := 0; i < argNum; i++ {
	if typeFunc.In(i).Kind() == reflect.Int {
		args[i] = reflect.ValueOf(3)  // Assign 3 to each parameter
	}
}
sumValue := valueFunc.Call(args)  // Returns []reflect.Value, because Go functions can return multiple values
if typeFunc.Out(0).Kind() == reflect.Int {
	sum := sumValue[0].Interface().(int)  // Convert from Value to the original data type
	fmt.Printf("sum=%d\n", sum)
}

Calling Methods

user := User{
	Id:     7,
	Name:   "John",
	Weight: 65.5,
	Height: 1.68,
}
valueUser := reflect.ValueOf(&user)               // Must pass a pointer, because BMI() is defined with a pointer receiver
bmiMethod := valueUser.MethodByName("BMI")         // MethodByName() returns a method by name
resultValue := bmiMethod.Call([]reflect.Value{})    // Pass an empty slice when there are no parameters
result := resultValue[0].Interface().(float32)
fmt.Printf("bmi=%.2f\n", result)

// Think() is defined with a value receiver, so valueUser can be either a pointer or a value
thinkMethod := valueUser.MethodByName("Think")
thinkMethod.Call([]reflect.Value{})

valueUser2 := reflect.ValueOf(user)
thinkMethod = valueUser2.MethodByName("Think")
thinkMethod.Call([]reflect.Value{})

Creating Objects

Creating a Struct

t := reflect.TypeOf(User{})
value := reflect.New(t)  // Create an object based on reflect.Type, get a pointer to it, then get the reflect.Value from the pointer
value.Elem().FieldByName("Id").SetInt(10)
user := value.Interface().(*User)  // Convert the reflection type back to a Go primitive data type

Creating a Slice

var slice []User
sliceType := reflect.TypeOf(slice)
sliceValue := reflect.MakeSlice(sliceType, 1, 3)
sliceValue.Index(0).Set(reflect.ValueOf(User{
	Id:     8,
	Name:   "Sarah",
	Weight: 80,
	Height: 180,
}))
users := sliceValue.Interface().([]User)
fmt.Printf("1st user name %s\n", users[0].Name)

Creating a Map

var userMap map[int]*User
mapType := reflect.TypeOf(userMap)
// mapValue := reflect.MakeMap(mapType)
mapValue := reflect.MakeMapWithSize(mapType, 10)

user := &User{
	Id:     7,
	Name:   "John",
	Weight: 65.5,
	Height: 1.68,
}
key := reflect.ValueOf(user.Id)
mapValue.SetMapIndex(key, reflect.ValueOf(user))                      // SetMapIndex adds a key value pair to the map
mapValue.MapIndex(key).Elem().FieldByName("Name").SetString("Mike")   // MapIndex retrieves the value for a key from the map
userMap = mapValue.Interface().(map[int]*User)
fmt.Printf("user name %s %s\n", userMap[7].Name, user.Name)

In addition to MakeSlice() and MakeMap(), the reflect package also provides MakeChan() and MakeFunc().

title: "[LeetCode] Binary Search Without the Edge Case Headaches" summary: "A single template for all binary search problems." date: 2025-08-10 tags: ["Binary Search", "Algorithms", "LeetCode", "Python"] featured: false

Binary Search Without the Edge Case Headaches

Binary search is supposed to be simple. Split the array in half, check the middle, repeat. But anyone who's spent time on LeetCode knows the real difficulty isn't the idea -- it's the implementation. left < right or left <= right? mid or mid + 1? Return left or right? Every problem feels like a fresh puzzle of off-by-one errors.

I used to re-derive the boundary logic for every single binary search problem. Eventually I settled on a fixed template that I've used on dozens of problems without failure. Here's the template, and more importantly, why it works.

The Template

left, right = 0, n - 1
while left <= right:
    mid = (right - left) // 2 + left
    if condition:
        left = mid + 1
    else:
        right = mid - 1

Three rules, no exceptions:

1. Loop condition is always while left <= right
2. Updates are always left = mid + 1 and right = mid - 1
3. Never return inside the loop -- decide what to return after the loop exits

Why It Works

When the loop exits, left = right + 1. Always. This isn't a heuristic -- you can prove it.

The loop runs as long as left <= right, so the interval [left, right] is non-empty on every iteration. Each branch strictly shrinks the interval because mid always lies within [left, right]. When the interval finally shrinks to left == right, we get mid == left == right, and one more branch pushes them past each other. The only possible exit state is:

The array has been partitioned into two halves. Every element that triggered left = mid + 1 is now on the left side (at or before right). Every element that triggered right = mid - 1 is on the right side (at or after left).

So right is the last element of the left half, and left is the first element of the right half.

Deciding the Return Value

Ask one question: which branch did my target get swept into?

If the target satisfies the condition that triggers left = mid + 1, it ended up in the left half. The last such element is right. Return right.

If the target satisfies the condition that triggers right = mid - 1, it ended up in the right half. The first such element is left. Return left.

That's the entire decision process. No case analysis, no finger-tracing through examples.

Example: LeetCode 34 (Find First and Last Position)

This problem asks for the leftmost and rightmost positions of a target in a sorted array. It needs two binary searches.

Finding the left boundary (first occurrence of target):

def find_left(nums, target):
    lo, hi = 0, len(nums) - 1
    while lo <= hi:
        mid = (lo + hi) // 2
        if nums[mid] < target:
            lo = mid + 1
        else:
            hi = mid - 1
    return lo

When nums[mid] == target, we go into the else branch (hi = mid - 1), pushing hi left past the match. So equal-to-target elements get swept by hi = mid - 1, landing in the right half. Return lo.

Finding the right boundary (last occurrence of target):

def find_right(nums, target):
    lo, hi = 0, len(nums) - 1
    while lo <= hi:
        mid = (lo + hi) // 2
        if nums[mid] <= target:
            lo = mid + 1
        else:
            hi = mid - 1
    return hi

When nums[mid] == target, we hit lo = mid + 1, pushing lo right past the match. Equal-to-target elements get swept by lo = mid + 1, landing in the left half. Return hi.

Putting it together:

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        def find_left():
            lo, hi = 0, len(nums) - 1
            while lo <= hi:
                mid = (lo + hi) // 2
                if nums[mid] < target:
                    lo = mid + 1
                else:
                    hi = mid - 1
            return lo

        def find_right():
            lo, hi = 0, len(nums) - 1
            while lo <= hi:
                mid = (lo + hi) // 2
                if nums[mid] <= target:
                    lo = mid + 1
                else:
                    hi = mid - 1
            return hi

        l, r = find_left(), find_right()
        return [l, r] if l <= r else [-1, -1]

The only difference between the two functions is < vs <=. That single character controls whether equal elements get pushed left or right.

Boundary Checks

The pointers can land outside the array. If every element is greater than the target, right ends up at -1. If every element is smaller, left ends up at n. Both cases still satisfy left = right + 1 -- the invariant holds even at the extremes.

So after the loop, always check that your returned index is within [0, n-1] and that nums[index] == target (or whatever your problem requires). The template guarantees the partition is correct; you just need to verify the answer exists.

Other Examples

LeetCode 278 (First Bad Version): Classic FFFFTTTTT partition. isBadVersion(mid) is true -> hi = mid - 1. Answer swept by hi, return lo.

LeetCode 35 (Search Insert Position): Find the first index where nums[i] >= target. nums[mid] >= target -> hi = mid - 1. Answer swept by hi, return lo.

Finding the last element '<=' target: nums[mid] <= target -> lo = mid + 1. Answer swept by lo, return hi.

Same template, same reasoning, every time.

title: "How gRPC Powers Recommendation and Inference in Django" summary: "Explore how Gastronome uses gRPC to handle ML-based recommendations and sentiment scoring asynchronously." date: 2025-07-03 tags: ["gRPC", "Django", "Microservices", "Recommendation System", "Celery", "Redis"] featured: true

How gRPC Powers Recommendation and Inference in Django

Gastronome is a sophisticated Django-based recommendation platform designed to provide users with personalized business suggestions, powered by advanced machine learning models. To achieve a highly responsive and scalable architecture, Gastronome leverages gRPC - a high-performance Remote Procedure Call (RPC) framework - to handle computationally intensive tasks asynchronously. This approach ensures the Django web application remains lightweight, fast, and responsive by offloading heavy workloads like recommendation computations and semantic sentiment scoring to dedicated microservices.

What is gRPC and Why Use It?

gRPC is an open-source framework developed by Google that enables efficient, language-neutral RPC communication between distributed systems. It relies on HTTP/2 for transport, uses Protocol Buffers (protobufs) for serialization, and supports bi-directional streaming. These attributes make gRPC especially suited for performance-critical applications and internal microservice communications.

gRPC in Gastronome's Architecture

Gastronome employs a modular microservices architecture, where the main Django web application interacts with two dedicated gRPC-powered services:

• Recommendation Service: Handles user-specific recommendation computations using collaborative filtering and matrix factorization methods, generating personalized business recommendations.
• Inference Service: Performs sentiment analysis using a fine-tuned DistilBERT model, assigning semantic sentiment scores to user reviews to enrich recommendations and user profiling.

The Django web app itself doesn't perform heavy computations inline. Instead, Celery asynchronous workers handle these tasks, interacting with the two gRPC microservices to process tasks in the background, ensuring minimal latency for user requests.

Illustrative Use Cases and Workflows

To clearly understand how Gastronome employs gRPC, let's explore two workflows within the platform:

1. Cache-miss Personalized Recommendation Flow

In this scenario, when a user requests personalized recommendations and there's a cache miss in Redis, Gastronome immediately returns a fallback popular recommendation list to ensure rapid response. Simultaneously, a Celery worker is dispatched asynchronously to call the Recommendation Service via gRPC. This service retrieves or trains the appropriate recommendation model and computes personalized recommendations. Upon completion, the results are cached in Redis, significantly accelerating future retrievals.

2. New Review Submission & Sentiment Analysis Flow

Here, Gastronome captures new user reviews quickly, storing them immediately in PostgreSQL with a placeholder sentiment score. A Celery worker then asynchronously contacts the gRPC-based Inference Service, where a fine-tuned DistilBERT model processes the review text to determine semantic sentiment. Once analyzed, the sentiment score is returned via gRPC, and the worker updates the review in the database, enhancing user profiles and future recommendations.

Why Celery and gRPC Work Together So Well

• Robust Scalability: By offloading heavy workloads to Celery workers and communicating via gRPC, Gastronome can independently scale recommendation and inference services without affecting the main Django application's responsiveness.
• Language Agnostic: gRPC enables microservices to be written in different programming languages. This flexibility allows you to pick the best language or framework for each service, making it easier to evolve or optimize parts of the system over time.
• Robustness: gRPC natively supports advanced reliability features like retries, deadlines (timeouts), and circuit breakers. Combined with Celery's task management and retry mechanisms, this architecture provides strong fault tolerance and keeps the system resilient even if individual services fail or become temporarily unavailable.

Closing Thoughts

Leveraging gRPC within Django is a powerful architectural decision that significantly enhances application maintainability and scalability. Gastronome's implementation showcases an effective pattern for Django applications that require advanced ML computations without sacrificing user experience.

By isolating ML workloads into dedicated microservices and communicating asynchronously through gRPC, Gastronome efficiently blends advanced machine learning capabilities with robust web application performance.