Forem: Nerdherd

Golang Pointers

Nerdherd — Mon, 16 Sep 2024 11:48:45 +0000

Coming from Ruby, thinking about Golang pointers does require a shift in thinking.

In Ruby,

Variables are references to objects.
When you assign one variable to another, both variables point to the same object.
Changing an object through any variable will be reflected across all references

# Variable array_a is a reference to an Array object
array_a = [1,2,3]

# array_b and array_c now points to the same Array object as array_a
array_b = array_a
array_c = array_a

# Updating array_b will update the underlying Array object defined by 'array_a'
# array_a, array_b and array_c will have the same output
array_b << 4
puts "a: " + array_a
puts "b: " + array_b
puts "c: " + array_c

# output
# a: [1,2,3,4]
# b: [1,2,3,4]
# c: [1,2,3,4]

In Go:

Variables can store actual values or pointers (memory addresses) to values.
Assigning one variable to another will copy the value
- This results in two independent variables
Pointers allow you reference the same data from multiple variables.-

Go pointers (*Type) references the memory address, where the data is stored.

It would like something like *string=0x14000114180.

Go values (Type) holds the actual data

Copying will create a new independent instance

// main.go

package main

import "fmt"

func main() {
  // Create an array of length 4, with initial values [1, 2, 3, 0]
  array_a := [4]int{1,2,3}

  // 'array_b' references the same underlying array as 'array_a'
  array_b := array_a
  array_c := array_c

  array_b[3] = 4
  fmt.Println("array_a: " array_a)
  fmt.Println("array_b: " array_b)
  fmt.Println("array_c: " array_c)
}

// output
// array_a:  [1 2 3 0]
// array_b:  [1 2 3 4] <-- only b changed
// array_c:  [1 2 3 0]

To achieve the same result as ruby, we would need to ensure that we are not "copying" the value of array_a to array_b and array_c.

Instead, we would need to assign array_b and array_c a pointer to array_a.

// main.go

package main

import "fmt"

func main() {
  // Create an array of length 4, with initial values [1, 2, 3, 0]
  array_a := [4]int{1,2,3}

  // 'array_b' and 'array_c' is a pointer to the memory address that stores the value of 'array_a'
  array_b := &array_a
  array_c := &array_c

  array_b[3] = 4

  // Since array_a does not store a pointer, we print it directly
  // array_a (value)
  // +-------------------+
  // | [1, 2, 3, 4]      |
  // +-------------------+
  //     ^
  //     |
  // &array_a (address) <--- array_c, array_b (pointers)
  //
  fmt.Println("array_a: ", array_a)
  // '*array_b' is called dereferencing
  // Since 'array_b' stores the pointer to 'array_a', weneed to "dereference it"
  fmt.Println("array_b: ", *array_b)
  fmt.Println("array_c: ", *array_c)
}

// output
// array_a:  [1 2 3 4]
// array_b:  [1 2 3 4] 
// array_c:  [1 2 3 4]

Intro to JS Variable Declarations

Nerdherd — Wed, 04 Sep 2024 05:48:38 +0000

Writing this guide for by father who is building alis4ops.com

I refer to him as "Baba".
He is learning to build web applications, formerly an Electrical Engineer who ran his own engineering business.
Will leave some notes around the article referring to him, so anyone on the interwebz reading this can ignore those lines. Hope you guys don't mind!

About alis4ops.com

A web app for children to practice their maths operations and for older people to keep the minds sharp.

It's a recreation of a Lotus 1-2-3 program my father wrote for my younger brother and me. This was more than 24 years ago. He was looking for an easier way for me to practice my multiplications without him having to manually generate the questions and mark my questions. He would be writing the tens of hundreds of questions on paper.

Context

We have the following functions:

handleStartTouch
handleMoveTouch

Baba defined in DragDrop.js

function handleStartTouch(event) {
    draggedElement = event.target;
    const touch = event.touches[0];
    touchStartX = touch.clientX - draggedElement.getBoundingClientRect().left;
    touchStartY = touch.clientY - draggedElement.getBoundingClientRect().top;
}

function handleMoveTouch(event) {
    event.preventDefault()
    if (draggedElement) {
        const touch = event.touches[0];
        // ..more code
    }
}

Notice that we are accessing draggedElement on line:

if (draggedElement) {

hanldeMoveTouch does not raise an error when it called.

Placing a breakpoint on if (draggedElement) in Chrome DevTools will show that draggedElement resolves to the same html element provided by event.target in handleStartTouch

Issue

Why can we can access draggedElement in handleMoveTouch even through it is defined in handleStartTouch

More generically, why can we access a variable which was defined in a function in another function in javascript?

Explanation

Look at handleStartTouch function:

function handleStartTouch(event) {
    draggedElement = event.target;
    const touch = event.touches[0];
    touchStartX = touch.clientX - draggedElement.getBoundingClientRect().left;
    touchStartY = touch.clientY - draggedElement.getBoundingClientRect().top;
}

Specifically the line:

    draggedElement = event.target;

It does not declare the variable name draggedElement using either one of the keywords

const
let
var

For example, we are not defining it like so:

    const draggedElement = event.target;

Variable Declaration (a.k.a Keywords)

In Javascript, when we do not use the variable declarations (also called keywords), javascript considers that variable a global variable.

Exercise

Consider the following example where we define two functions:

// Takes in two arguments and returns the sum
function add(x, y) {
  sum = x + y
  return sum
}

// prints sum if it is defined
function printStatus() {
  if (sum) {
    console.log("Sum: ", sum)
  } else {
    console.log("Sum does no exist")
  }
}

Open up DevTools in Chrome

navigate to "Console"
Copy and paste the code above
Press enter
It will return undefined, thats fine.

In the console, call add(1,1)

you will see the console return 2

add(1,1)
=> 2

Then call printStatus

You will see the output Sum: 2

We can see that printStatus() can access the variable sum defined in add(x, y)

This is because the variable sum is being declared without this following keywords:

sum = x + y

Now lets change add(x, y) add to use a variable declaration for sum

// Takes in two arguments and returns the sum
function add(x, y) {
  const sum = x + y // use the variable declartion const
  return sum
}

// prints sum if it is defined
function printStatus() {
  if (sum) {
    console.log("Sum: ", sum)
  } else {
    console.log("Sum does no exist")
  }
}

Go to Chrome
Refresh the page with Ctrl + R
- you can also open a new tab and open up devtools console again.

Let's define the functions in the console log again.

Copy and paste the code snippet above into the console and press enter.

We need to redefine it because we are started a new dev console.

Now in the console, call add(2, 2)

you will see the console return 4

Call printStatus to see if can access the variable sum defined in add(x, y)

printStatus()
> Uncaught ReferenceError: sum is not defined
    at printStatus (<anonymous>:9:3)
    at <anonymous>:1:1

The error says sum is not defined.

This confirms that when a variable is defined with a variable declaration (const, let, var) within a function, that variable's scope is only within the function.

Summary

function add(x, y) {
  // Globally scoped "sum"
  sum = x + y
  return sum
}

function add(x, y) {
  // Scoped only within this function
  const sum = x + y
  return sum
}

Hope this helps Baba! (and anyone else reading this.)

Golang Struct Field Scopes

Nerdherd — Sat, 31 Aug 2024 11:36:16 +0000

Struct Field Scopes

Exported Fields

In other languages, this would be similar to the public access qualifier.

If you come from Ruby like me, this would be defining attributes with attr_accessor

If the field (i.e. attribute) of the struct starts with an upper case, it would mean that that field is exported, thus accessible outside of the package.

Assume we have the following files in Go project:



main.go
/library
  /book.go

We would define book.go in it's own package.



// library/book.go

// Assume we have a package called "library" which contains a book.
package library

// Struct that represents a physical book in a library with exported fields
type Book struct {
  Title string
  Author string
}

When using it in main.go:



package main

import (
  "fmt"
  "library" // importing the package that the struct Book is in
)

func main() {
  book := library.Book{
    Title: "Book Title",
    Author: "John Snow"
  }
  // Print the title and author to show that the struct Book fields are accessible outisde it's package "library"
  fmt.Println("Title:", book.Title)
  fmt.Println("Author:", book.Author)
}

In Ruby, this would be synonymous with using attr_accessor since we can:

read and write the attribute values outside of the class



class Book
  # allow read and write on the attributes from outside the class
  attr_accessor(:title, :author)

  def initalize(title = nil, author = nil)
    @title  = title
    @author = author
  end
end

# usage outside of the class
book = Book.new()

# assinging attributes outside of the class
book.title = "Book Title"
book.title = "Jon Snow"

# accessing attributes outside of the class
puts book.title, book.author

Private Fields

This is similar to private access qualifiers in other languages

If it starts with a lower case, the fields will not be accessible.

Try it for yourself!

Assuming your module name is myapp in go.mod



// go.mod
module myapp

go 1.22.5

We create a new file in library/book.go under the package library



// library/book.go

// Assume we have a package called "library" which contains a book.
package library

// Fields start with lowercase, fields are not exported
type Book struct {
  title string
  author string
}

Import the package into main.go



// main.go
package main

import (
  "fmt"
  // import the library package
  "myapp/library"
)

func main() {
  book := library.Book{
    title: "Book Title",
    author: "John Snow"
  }
  // Print the title and author to show that the struct Book fields are accessible outisde it's package "library"
  fmt.Println("title:", book.title)
  fmt.Println("author:", book.author)
}

If you have Go setup in VSCode, you would get the following lint error:

unknown field author in struct literal of type library.Bookcompiler[MissingLitField](https://pkg.go.dev/golang.org/x/tools/internal/typesinternal#MissingLitField

Intro to GoLang Structs

Nerdherd — Thu, 29 Aug 2024 18:43:43 +0000

In Golang, structs are simple containers for data.

can have fields
no methods attached to them
- methods defined separately and associated with a struct type.

The following show a simple Book class equivalents in Ruby and GoLang.

class Book
  attr_reader(:title, :author)

  def initalize(title, author)
    @title  = title
    @author = authoer
  end
end

# usage
book = Book.new('Title', 'Jon Snow')

// Equivalent to `class Book` in ruby
type Book struct {
  Title string,
  Author string
}

Instantiating GoLang `type`

Composite Literal

Composite Literal is syntax to create an initialise composite types in one step. We can instantiate the following types:

structs
arrays
slices
maps

Here we are assigning a new Book instance to the variable book

// Composite Literal
book := Book{
  Title: "Title",
  Author: "Author"
}

Using `new` keyword

The longer form is to use the new keyword. This would be similar to the way we would instantiate a class in Ruby with book = Book.new(..)

We would assign the attributes of the book (i.e. Title and Author) using = sign.

// Using the `new` keyword
book        := new(Book)
book.Title  = "Book Title"
book.Author = "John Snow"

Without Short Variable Declaration (`:=`)

Notice that we used the symbol := in the first example?

It's syntactic sugar for the following verbose way of declaring a variable and assigning it a value.

// Without Short Virable Declaration

// Example 1
var book Book // Declare variable `book` of type `Book`
book.Title = "Book Title" // Assign the value to book variable
book.Author = "John Snow"

// Example 2
var count int
count = 20

Factory Function

We could also use the factory pattern to make it easier when initialising the struct when we need to:

add additional logic
add default values

Assuming we would want to make each first character of the book's title and author tokens to be capitalised.

// Factory Function
func NewBook(title string, author string) Book {
  return Book{
    Title: titlelise(title), // default logic to "titlelise" 
    Author: titlelist(author)
  }
}

func titlelise(str string) {
  caser := cases.Title(lanaguage.English)
  return caser.String(str)
}

Attaching a function to a `struct`

In Ruby, we would simply define a function within the class. Here, we are defining a function called to_string() to print the book title name author.

class Book
  attr_reader(:title, :author)

  def initalize(title, author)
    @title  = title
    @author = authoer
  end

  # new function we added
  def to_string()
    put "#{title} by #{string}"
  end
end

In GoLang, we would "attach" the function by passing in the stuct to the function.

// Equivalent to `class Book` in ruby
type Book struct {
  Title string,
  Author string
}

// Attaching the function to the `struct`
func (book Book) ToString() string {
  return fmt.Sprintf("%s by %s", book.Title, book.Author)
}

// Usage
book := Book{
  Title: "Title",
  Author: "Author"
}

book.ToString()
// => Title by Author

Explanation of:

func (book Book) ToString() string

Token	Description
`func`	function keyword
`(book Book)`	Attaching the function to the `type Book struct` - `book`: variable to access the `struct` within the function - `Book`: type of the `struct`
`ToString()`	name of the function
`string`	return type of the function

Setting up Delve and Air to debug Golang with VS Code

Nerdherd — Fri, 09 Aug 2024 15:30:49 +0000

I could not find an in-depth guide on setting up debugging with VS Code.

Decided to go into detail to go through each step understanding the fundamentals of the process like:

Meanings of the options in various commands
How the the tools work

VS Code Extension

Search for Go in VS Code Extensions and install it.

https://marketplace.visualstudio.com/items?itemName=golang.Go

Debugger

You will need to install Delve to get debugging (breakpoints, step through, etc) in VS Code.

go install github.com/go-delve/delve/cmd/dlv@latest

If you used asdf to install Go, delve will be located in:

~/.asdf/shims/dlv

You might want to run asdf reshim after installing a go package.

Live Reloading

Since GoLang is a compiled language, code will be compiled into a single executable. During development, making changes will require us to constantly recompile, which can be a manual process, especially in VS Code.

We will use https://github.com/air-verse/air to do live reloading for us.

It is a command line tool that only needs to be run once within your project folder to watch for changes.

Installation

Install the package. Assuming you have go v1.22 or higher.

go install github.com/air-verse/air@latest

If you used asdf to install Go, air will be located in:

~/.asdf/shims/air

Initialise an air.toml config file in your project root

cd ~/myproject
air init

Edit air.toml's go build command like so:

- cmd = "go build -o ./tmp/main ."
+ cmd = 'CGO_ENABLED=0 go build -gcflags=all="-N -l"-o ./tmp/main .'"'

all: flags should be applied to all packages in build packages
-N: disabled optimisations to ensure generated code closer to source code for easier debugging
-l: disables inlining optimisation where small functions are expanded in place to reduce overhead of function calls, making it easier for debugging
Reasoning from Delve Reference

INFO
air will run with default configurations if:

air.toml file is invalid

You ran the command air without air -c air.toml

It will not use your air.toml file.

Edit air.toml full_bin to run the built binary with [[Delve]].

- full_bin = ""
+ full_bin = "dlv exec ./tmp/main --listen=127.0.0.1:2345 --headless=true --api-version=2 --accept-multiclient --continue --log --"

This will run Delve on port 2345.

Run air in your project folder. You should see the following output.

> cd ~/my-project
> air
  __    _   ___  
 / /\  | | | |_) 
/_/--\ |_| |_| \_ v1.52.3, built with Go go1.22.5

mkdir ~/my-project/tmp
watching .
!exclude tmp
building...
running...
API server listening at: 127.0.0.1:2345
2024-07-28T18:47:07+07:00 info layer=debugger launching process with args: [./tmp/main]
2024-07-28T18:47:09+07:00 debug layer=debugger entryPoint 0x1006e8000 machoOff 0x100000000
2024-07-28T18:47:09+07:00 warning layer=debugger debug_frame workaround not applied: function internal/abi.(*RegArgs).IntRegArgAddr (at 0x1006e9070) covered by 0x1006e9070-0x1006e9110
2024-07-28T18:47:09+07:00 debug layer=debugger Adding target 11503 "/Users/alaay/projects/scheduleasy/tmp/main"
2024-07-28T18:47:09+07:00 debug layer=debugger continuing
2024-07-28T18:47:09+07:00 debug layer=debugger ContinueOnce
2024/07/28 18:47:09 Starting server on :5602

Attaching VS Code to Delve

In your .vscode/launch.config file, add the following:

{
  // Use IntelliSense to learn about possible attributes.
  // Hover to view descriptions of existing attributes.
  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Attach to Air",
      "type": "go",
      "request": "attach",
      "mode": "remote",
      "port": 2345,
      "host": "127.0.0.1"
    }
  ]
}

In VS Code Run and Debug (CMD + SHIFT + D), start debugging with Attach to Air

[!info] VS Code unable to connect
If VS Code is unable to connect, it is most likely that Delve is not running on port 2345. Try using lsof -i :2345 to check if dlv is running using that port. If it is running, you should see:
$ lsof -i :2345
COMMAND   PID  USER   FD   TYPE             DEVICE SIZE/OFF NODE NAME
dlv     15464 username    3u  IPv4 0x201bff14586139e3      0t0  TCP localhost:dbm (LISTEN)

Gotchas

Go is a compiled language. That means that code is compiled into a binary and then executed. Whenever we make changes to the code in vscode:

air will watch for the changes
rebuild the binary
start Delve at 2345

This means that the vscode will be disconnected and you will need to reattach vscode to delve.

Reach out

If anyone has a solution to the gotchas above, please leave a comment! I would really love to find a solution to this.

I come from a Rails background, so I'm super used to being able to just leave the debugger running while I make changes to the code.

References

These great guides helped me out when I first started setting up:

Installing Golang on MacOS

Nerdherd — Fri, 09 Aug 2024 14:37:21 +0000

This guide is what I did to get Golang setup on my Mac machine.

Assumptions

You use the following:

asdf
zshrc

Install Golang

From asdf-golang

asdf plugin add golang https://github.com/asdf-community/asdf-golang.git
# install latest golang version
asdf install golang latest

# set the glboal version for golang to latest
asdf global golang latest

# reshim 
asdf reshim golang

Add GOROOT in your shell's initialisation

GOROOT is the environment variable that specifics the location of the Go installation

Add the following to ~/.zshrc

. ~/.asdf/plugins/golang/set-env.zsh

This will ensure that GOROOT and GOPATH is set each time you run your terminal

GOROOT: specifies location of the Go installation directory (e.g. compiler, linker, standard library)
GOPATH: specifies location of your workspace. Workspace is a directory hierachy with three directories: src, pkg, bin

You can see what set-env.zsh does:

$ cat ~/.asdf/plugins/golang/set-env.zsh

asdf_update_golang_env() {
  local go_bin_path
  go_bin_path="$(asdf which go 2>/dev/null)"
  if [[ -n "${go_bin_path}" ]]; then
    export GOROOT
    GOROOT="$(dirname "$(dirname "${go_bin_path:A}")")"

    export GOPATH
    GOPATH="$(dirname "${GOROOT:A}")/packages"
  fi
}

autoload -U add-zsh-hook
add-zsh-hook precmd asdf_update_golang_env

Update your currently opened terminal to use latest ~/.zshrc

source ~/.zshrc

Check to see if GOROOT and GOPATH is set

> echo $GOROOT
/Users/username/.asdf/installs/golang/1.22.5/go

> echo $GOPATH
/Users/username/.asdf/installs/golang/1.22.5/packages