Coder Legion - Recent posts tagged value

Main Idea of Least Squares Method and Linear Regression

Tue, 07 Jul 2026 10:15:30 +0000

Hello, I'm Ganesh. I'm building git-lrc, an AI code reviewer that runs on every commit. It is free, unlimited, and source-available on Github. Star git-lrc on GitHub to help more developers discover the project. Do give it a try and share your feedback for improving the product.

Linear Regression is a method that finds the best fitting line for a set of data points.

It is used to predict the value of a dependent variable based on the value of one or more independent variables.

let's assume we have a set of data points $(x_1, y_1), (x_2, y_2), ..., (x_n, y_n)$.

The data points can be represented as a scatter plot.

The data points are scattered in a way that it may represent a line.

where each point $(x_i, y_i)$ represents a data point.

A line can be represented as $y = mx + b$, where $m$ is the slope and $b$ is the y-intercept.

Usually, we have some random value of $m$ and $b$ and we want to find the best value of $m$ and $b$ such that the line passes through the data points.

For example in this graph there are mulitple data points, and we want to find the best fitting line for these data points.

This can be done using the least squares method.

Least Squares Method

The least squares method is a method that finds the best fitting line for a set of data points.

we calculate the sum of the squares of the differences between the actual values and the predicted values.

$(y_i - (mx_i + b))^2$

We want to minimize this value.

So, we check each state of line and calculate the sum of the squares of the differences between the actual values and the predicted values.

We choose the line that minimizes this value.

How this is done mathematically

This whole caculation can be done mathematically. I will discuss in depth in my next article.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.

⭐ Star git-lrc on GitHub

Understanding Importance Derivation

Fri, 29 May 2026 05:03:12 +0000

Hello, I'm Ganesh. I'm building git-lrc, an AI code reviewer that runs on every commit. It is free, unlimited, and source-available on GitHub. Star git-lrc on GitHub to help more developers discover the project. Do give it a try and share your feedback for improving the product.

If you have learned differentiation in your school/college days, then most of us have learnt differentiation formula

But we couldn't just understand how this was actually defined. Let's just plot on a graph and see.

Practicality of Differentiation

Let's take an example of velocity and acceleration.

Whenever a ball is thrown in the air, it will travel in a curved path, which is also called parabolic motion.

Initially, based on acceleration, the velocity will be a peak, and at the highest point it will be zero, and again it increases while coming down.

This is how it looks:

Similarly, we can plot it as this.

If we differentiate it, we would get a straight line in the graph, also known as a slope.

So basically from this graph we can get the exact velocity value at this specific point of acceleration.

This is mainly used in physics and mechanical engineering, where we need the exact value of slope at a specific point.

Why it matters in neural networks?

In a neural network, we use the chain rule to derive the weights and bias.

Will talk about this in detail with proper examples.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.

⭐ Star git-lrc on GitHub

Understanding Interface in Go

Tue, 31 Mar 2026 22:11:11 +0000

Hello, I'm Ganesh Kumar. I'm working on git-lrc: a Git hook for Checking AI generated code.AI agents write code fast. They also silently remove logic, change behavior, and introduce bugs -- without telling you. You often find out in production.git-lrc fixes this. It hooks into git commit and reviews every diff before it lands. 60-second setup. Completely free.

In my previous post, I explained how methods works.

In this article we will understand how to work with interface.

What is an interface?

An interface is a type that defines a set of methods. It is used to define a contract for a type. It is an abstract signature of a type where we define the methods but not the implementation.


package main

import "fmt"

type shape interface {
    area() float64
}

type rectangle struct {
    width, height float64
}

func (r rectangle) area() float64 {
    return r.width * r.height
}

func main() {
    rect := rectangle{width: 10, height: 20}
    fmt.Println(rect.area())
}

Output:

gk@jarvis:~/exp/code/rd/go-exmaple$ go run main.go 
200

Interface are container which contains two properties.

Dynamic Type
Dynamic Value

Dynamic Type and Dynamic Value

Dynamic type is the type of the value stored in the interface.

package main

import "fmt"

func main() {
    // 'i' is an empty interface. Currently, both its dynamic type and value are nil.
    var i any 
    fmt.Printf("Value: %v \t Type: %T\n", i, i)

    // Now we assign an integer to it.
    // Dynamic Type becomes 'int', Dynamic Value becomes '42'
    i = 42
    fmt.Printf("Value: %v \t Type: %T\n", i, i)

    // Now we assign a string to it.
    // Dynamic Type becomes 'string', Dynamic Value becomes "Hello"
    i = "Hello"
    fmt.Printf("Value: %v \t Type: %T\n", i, i)

    // Now we assign a float to it.
    // Dynamic Type becomes 'float64', Dynamic Value becomes 3.14
    i = 3.14
    fmt.Printf("Value: %v \t Type: %T\n", i, i)
}

Output:

gk@jarvis:~/exp/code/rd/go-exmaple$ go run main.go 
Value: <nil>     Type: <nil>
Value: 42        Type: int
Value: Hello     Type: string
Value: 3.14      Type: float64

We can see that the dynamic type and dynamic value changes based on the value assigned to the interface.

Dynamic Type and Dynamic Value using reflection

This is another way to get the dynamic type and dynamic value.

package main

import (
    "fmt"
    "reflect"
)

// A custom struct
type User struct {
    Name string
}

func main() {
    var data interface{} = User{Name: "Alice"}

    // Extracting the dynamic type
    dynamicType := reflect.TypeOf(data)

    // Extracting the dynamic value
    dynamicValue := reflect.ValueOf(data)

    fmt.Println("Reflect Type:", dynamicType)         // main.User
    fmt.Println("Reflect Value:", dynamicValue)       // {Alice}

    // You can even check the underlying "Kind" (e.g., struct, int, ptr)
    fmt.Println("Kind of Type:", dynamicType.Kind())  // struct
}

Output:

gk@jarvis:~/exp/code/rd/go-exmaple$ go run main.go 
Reflect Type: main.User
Reflect Value: {Alice}
Kind of Type: struct

This way we can get the dynamic type and dynamic value using reflection.

Type Assertion

Type assertion is used to extract the dynamic value from the interface.

This is the basic way to use type assertion.

We try to extract the dynamic value from the interface. As, go is a static typed language, it will throw an error if the dynamic type is not the same as the type we are trying to extract.

package main

import "fmt"

func main() {
    var i interface{} = "Hello"

    s := i.(string)
    fmt.Println(s)

    s, ok := i.(string)
    fmt.Println(s, ok)

    f, ok := i.(float64)
    fmt.Println(f, ok)

    f = i.(float64)
    fmt.Println(f)
}

If we try to extract the dynamic value from the interface with a different type, it will throw an error.

To avoid this we first check if the dynamic type is the same as the type we are trying to extract.

Output:

gk@jarvis:~/exp/code/rd/go-exmaple$ go run main.go 
Hello
Hello true
0 false
panic: interface conversion: interface {} is string, not float64

Usage of Type Switch

Based on the dynamic type, we can extract the dynamic value from the interface.

package main

import "fmt"

func printTypeAndValue(i interface{}) {
    fmt.Printf("Type: %T\tValue: %v\n", i, i)
    switch i.(type) {
    case int:
        fmt.Printf("it is int %v\n", i)
    case string:
        fmt.Printf("it is string %v\n", i)
    case bool:
        fmt.Printf("it is bool %v\n", i)
    default:
        fmt.Printf("unknown")
    }
}

func main() {
    // 'i' is an empty interface. Currently, both its dynamic type and value are nil.
    printTypeAndValue("Hello")
    printTypeAndValue(42)
    printTypeAndValue(true)
}

Now we can see that based on the dynamic type, we can extract the dynamic value from the interface. We can print the value base on the dynamic type.

Output:

gk@jarvis:~/exp/code/rd/go-exmaple$ go run main.go 
Type: string    Value: Hello
it is string Hello

Conclusion

In this article we understood how interface works. We also understood how to use type assertion and type switch.

Check out: git-lrc
Any feedback or contributors are welcome! It’s online, open-source, and ready for anyone to use.
⭐ Star it on GitHub:

HexmosTech / git-lrc

Free, Unlimited AI Code Reviews That Run on Commit

git-lrc

Free, Unlimited AI Code Reviews That Run on Commit

AI agents write code fast. They also silently remove logic, change behavior, and introduce bugs -- without telling you. You often find out in production.

git-lrc fixes this. It hooks into git commit and reviews every diff before it lands. 60-second setup. Completely free.

See It In Action

See git-lrc catch serious security issues such as leaked credentials, expensive cloud

Understanding Methods in Go

Wed, 25 Mar 2026 22:30:59 +0000

In my previous post, I explained how closure works.

In this article we will understand how to method works.

Method

Method is a function with a receiver.

This works like a class method in other languages.

Here is the example of method.

let's define a struct value and add method to it.


package main

import "fmt"


type value struct {
    X, Y int
}



func (v value) add() int {

return v.X + v.Y
}

func main() {
    val := value{1,2}

    fmt.Println(val.add())
    val2 := &value{1,2}
    fmt.Println(val2.add())
}

Output:

gk@jarvis:~/exp/code/rd/go-exmaple$ go run main.go 
3

This is a simple example of method.

Pointer receiver

Pointer receiver is used to modify the value of the struct.


package main

import "fmt"


type value struct {
    X, Y int
}



func (v *value) add() int {

v.X += 1
v.Y += 1
return v.X + v.Y
}

func main() {
    val := value{1,2}
    fmt.Println(val.add())
    println(val.X,val.Y)
}

Output:

gk@jarvis:~/exp/code/rd/go-exmaple$ go run main.go 
3
2 3

From this we can see that pointer receiver is used to modify the value of the struct.

Conclusion

In this article we understood how method works and how pointer receiver is used to modify the value of the struct.

Check out: git-lrc
Any feedback or contributors are welcome! It’s online, open-source, and ready for anyone to use.
⭐ Star it on GitHub:

HexmosTech / git-lrc

Free, Unlimited AI Code Reviews That Run on Commit

git-lrc

Free, Unlimited AI Code Reviews That Run on Commit

AI agents write code fast. They also silently remove logic, change behavior, and introduce bugs -- without telling you. You often find out in production.

git-lrc fixes this. It hooks into git commit and reviews every diff before it lands. 60-second setup. Completely free.

See It In Action

See git-lrc catch serious security issues such as leaked credentials, expensive cloud operations, and sensitive material in log statements

git-lrc-intro-60s.mp4

Why

AI agents silently break things. Code removed. Logic changed. Edge cases gone. You won't notice until production.
Catch it before it ships. AI-powered inline comments show you exactly what changed and what looks wrong.
Build a habit, ship better code. Regular review → fewer bugs → more robust code → better results in your team.
Why git? Git is universal. Every editor, every IDE, every AI…

View on GitHub

Understanding Closures in Go

Mon, 23 Mar 2026 10:11:14 +0000

In my previous post, I explained how anonymous functions created and understand how it works.

In this article we will understand how closure.

What is closure

A closure is a function value that references variables from outside its body.

The function may access and assign to the referenced variables; in this sense the function is "bound" to the variables.

How closure is used?

Each time new value updates the sum variable.

Next time when we call the function, it will use the updated value of sum.

So, It remembers the value of sum.


package main

import "fmt"
func adder(x int) func(int) int {
    sum := 0
    return func(y int) int {
        sum += y
        return sum
    }
}


func main() {
   pos,neg := adder(0),adder(0)
   for i := 0; i < 10; i++ {
        fmt.Println(
            pos(i),
            neg(-i),
        )
    }

}

Output:

gk@jarvis:~/exp/code/rd/go-exmaple$ go run main.go 
0 0
1 -1
3 -3
6 -6
10 -10
15 -15
21 -21
28 -28
36 -36
45 -45

Fibonacci series

Here is the example of fibonacci series.
initially we are initializing a and b with 0 and 1.

then with each time calling the function it will return the return value of a.

and update the value of a and b.

So, hence creating a fibonacci series.

package main

import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
    a, b := 0, 1
    return func() int {
        ret := a
        a, b = b, a+b
        return ret
    }
}

func main() {
    f := fibonacci()
    for i := 0; i < 10; i++ {
        fmt.Println(f())
    }
}

Output:

gk@jarvis:~/exp/code/rd/go-exmaple$ go run main.go 
0
1
1
2
3
5
8
13
21
34

Conclusion

In this article we understood how closure is used. closure is a function value that references variables from outside its body.

Check out: git-lrc
Any feedback or contributors are welcome! It’s online, open-source, and ready for anyone to use.
⭐ Star it on GitHub:

HexmosTech / git-lrc

Free, Unlimited AI Code Reviews That Run on Commit

git-lrc

Free, Unlimited AI Code Reviews That Run on Commit

AI agents write code fast. They also silently remove logic, change behavior, and introduce bugs -- without telling you. You often find out in production.

git-lrc fixes this. It hooks into git commit and reviews every diff before it lands. 60-second setup. Completely free.

See It In Action

See git-lrc catch serious security issues such as leaked credentials, expensive cloud operations, and sensitive material in log statements

git-lrc-intro-60s.mp4

Why

AI agents silently break things. Code removed. Logic changed. Edge cases gone. You won't notice until production.
Catch it before it ships. AI-powered inline comments show you exactly what changed and what looks wrong.
Build a habit, ship better code. Regular review → fewer bugs → more robust code → better results in your team.
Why git? Git is universal. Every editor, every IDE, every AI…

View on GitHub