Nil Pointer Exception in Global space

I'm trying to understand the concept of pointers.

I have three packages main, models and controller

in my models.go

type Database struct {
	config 	string
	port 	int
}

var DB *Database

func GetDatabase() *Database {
	fmt.Println("Reporting from Models.")
	DB = &Database{config: "This is stunning!", port: 3306}
	fmt.Printf("%v, %T\n", DB, DB)
	return DB
}

in controller.go

var DB *models.Database = models.DB

func GetController() {
	fmt.Println("Reporting from Controllers!")
	fmt.Printf("%v, %T\n", DB, DB)
}

in main.go

var DB *models.Database

func main() {
	DB = models.GetDatabase()
	controllers.GetController()
	fmt.Println("REporting from main")
	fmt.Printf("%v, %T\n", DB, DB)
}

The OUTPUT

Reporting from Models.
&{This is stunning! 3306}, *models.Database
Reporting from Controllers!
<nil>, *models.Database
REporting from main
&{This is stunning! 3306}, *models.Database

My question here is why am I getting nil inside my controller for DB? My intuition is that its accessing the global DB variable at package level inside models which is nil since its not initiated. But since its a reference and I'm trying to give it a proper reference inside my GetDatabase function why is that change not getting reflected when I try to access that variable inside my controller?

If you want to share something you need a pointer, but NOT a nil pointer, an actual allocated one. Then you also need to use dereferencing to be able to update every instance of the shared pointer, basically dereferencing is how you update data stored at the address to which the pointer points.

var DB = &Database{}

func GetDatabase() *Database {
    // an asterisk before an expression is how you dereference a pointer
    *DB = Database{config: "This is stunning!", port: 3306}
}

var DB = models.DB

func GetController() {
    fmt.Printf("%v, %T\n", DB, DB) // not nil anymore
}

var DB = models.DB

func main() {
    // you can ommit the assignment since GetDatabase() updates the shared 
    // pointer of models.DB
    _ = models.GetDatabase()
    fmt.Println(DB)
}

Pointers are essentially integers, where the number they store is the address of some other variable in memory. If you're not used to pointers, but come from a language that has arrays, it's more or less correct to think of pointers as integers holding array indexes, where the array is memory.

When you run a statement like, this....

package controllers

var DB *models.Database = models.DB

What you're really doing here is effectively integer assignment, where the value of models.DB is copied by value into the variable controllers.DB. At the point in time where this line of code is executed, the value of models.DB is nil, so you copy the address nil into controllers.DB.

After this copy-by-value, any changes to the models.DB variable are completely decoupled from the controllers.DB variable. They're two separate things, and they both point to nil. Now, when you assign address of some actual DB instance to models.DB, the value of models.DB changes, but the unrelated variable controllers.DB is unaffected.

Changes to one variable (ie assignment) don't get mirrored to other variables. But, if two pointers point to the same memory, and you change the memory itself, then the changes are visible through both pointers.

If you did this...

models.DB = &Database{} // non-nil address
controllers.DB = models.DB // non-nil address is copied

then both variable would contain the same address, and changes to the single Database variable they both now point to would be visible through both pointers. However, reassigning the variable itself, ie models.DB = nil, will not affect the other variable.

Going back to the array example, you've effectively done this:

arr := []string{"zero", "one", "two", "three"}

idx1 := 0 // ie models.DB
idx2 := 0 // ie controllers.DB

idx1 = idx2 // copy 0 by value into idx1

idx2 = 1 // does not affect idx1, which is still 0

arr[idx1] // "zero"
arr[idx2] // "one"