Forem: Mofi Rahman

Go Crash Course XI: Pointers

Mofi Rahman — Fri, 04 Jun 2021 01:01:14 +0000

Pointers

If you are coming from something like c or c++ you should be familiar with pointers. Go has pointers too. A pointer is a memory address of a variable.

i := 10
fmt.Println(&i)
n := &i
fmt.Println(n)
fmt.Println(i)
*n = 15
fmt.Println(i)

There are a few things going on in these few short lines of code.

Address of a variable

We can access the address of a variable with & operator. Here we have a variable i so &i gives us the memory address of i.

Pointer type

We create a new variable n with the value &i. If we check the type of n with fmt.Printf("%T\n", n) we will see the type is *int.

Pointer De-referencing

If we have a value of pointer type how do we get the actual value the pointer is pointing to? Thats where pointer de-referencing comes into play. We already seen an example of that actually.

*n = 15

We de-reference n with the * operator to access the underlying value and assign 15 to it.

Passing pointers to function

If we want to persist the change to a variable passed to a function we need to pass it as pointers.

func pointer(x *int) {
    *x = 10
}

func value(x int) {
    x = 10
}

func main(){
    a := 5
    fmt.Println(a) // value is 5
    pointer(&a)
    fmt.Println(a) // value is 10
    a = 5
    fmt.Println(a) // value is 5
    value(a)
    fmt.Println(a) // value is still 5
}

The same goes for arrays and slices as well. If we pass an array as value and make any changes to it, it wont persist.

func arrval(a []int) {
    a = append(a, 5)
}

func arrpointer(a *[]int) {
    *a = append(*a, 5)
}

func main() {
    ar := []int{1, 2, 3, 4}
    fmt.Println(ar) // [1 2 3 4]
    arrval(ar)
    fmt.Println(ar) // [1 2 3 4]
    arrpointer(&ar)
    fmt.Println(ar) // [1 2 3 4 5]
}

One of the main exceptions to this is map. If we pass a map to a function. Map types are pointers by default. We will discuss this further when we talk about maps.

Pointer receivers

On methods we can have pointer receivers. If a type has a pointer receiver method any changes to the type in the method will persist. This was covered in the section about methods and partly in interfaces.

Next Steps

This is Part 11 of this Go crash course series.

Go Crash Course Part X: Interfaces, Type Cast and Type Switching

Mofi Rahman — Mon, 24 May 2021 21:13:56 +0000

Interface

Interface is a collection of method signatures. In go interfaces are implemented implicitly. So it is possible for a single type to implement multiple interfaces. For example the os.File type implements dozens of interfaces from the io package alone like Reader, Writer, ReadCloser, ReadSeeker, Closer, WriteSeeker. Because it is implicit it can also implement newer interfaces from other packages and from packages you write.

Implementing Interface

Any user defined type can implement interfaces. Usually we see interfaces implementation on structs. But we can very easily do this on any other type definitions.

type bob int

func (b bob) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("hello world!"))
}

This bob type here now implements the handler interface and can be used to serve http request.

But usually we would be using a struct type to implement interface because we need additional fields in our methods.

Lets look at the classic shape interface

type Shape interface {
    Area() float64
}

So something is a Shape as long as it implements the methods listen in Shape interface.

type Circle struct {
    Radius float64
}

type Rectangle struct {
    Width  float64
    Height float64
}

func (c *Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

func (r Rectangle) Area() float64 {
    return r.Height * r.Width
}

Now we have two struct Circle and Rectangle that has the Area method. Pay attention to the pointer receiver on type Circle's Area method.

func GetArea(s Shape) float64 {
    return s.Area()
}

func main() {
    circle := Circle{5.0}
    r1 := Rectangle{4.0, 5.0}
    r2 := &Rectangle{10.0, 15.0}
    GetArea(circle) // this will give error
    GetArea(r1)
    GetArea(r2)
}

Say we have a function called GetArea that takes Shape. Then we can create a few variables of type Circle and Rectangle. circle is of type Circle, r1 is of type Rectangle and r2 is of type *Rectangle. Since Area method is is attached to value receiver of Rectangle both r1 and r2 can be used as Shape. But circle does not work as Shape. The exact error we get is

cannot use circle (type Circle) as type Shape in argument to GetArea:
        Circle does not implement Shape (Area method has pointer receiver)

Basically if a method has pointer receiver to satisfy the interface we need the pointer of the type. Which is a bit different to how structs work. We can call Area on value of circle

area := circle.Area() // this works fine although circle is a value

Type Cast

We can store any value in a variable of type interface

var x interface{} = "hello"

str, ok := x.(string)

We can create a variable x with value "hello". Since we know the value is of type string we can type cast that interface using the .(type) syntax. This returns the value and a bool which is set to false if the value could not be converted. Notice we can only do this because the underlying type was string. We can do similar things for structs as well.

Type Switches

var y interface{} = "go"
switch v := y.(type) {
case int:
    fmt.Printf("Twice %v is %v\n", v, v*2)
case string:
    fmt.Printf("%q is %v bytes long\n", v, len(v))
default:
    fmt.Printf("I don't know about type %T!\n", v)
}

The use cases for these are not as common. Usually in Go we try not to pass around interface{} unless we absolutely have to. We might see specific interface being passed to function. But in those cases we never have to type cast them to concrete types as we are more interested in the behavior rather than the underlying fields.

Next Steps

This is Part 10 of this Go crash course series.

Go Crash Course Part IX: Structs, Embedding and Methods

Mofi Rahman — Tue, 18 May 2021 02:31:50 +0000

Struct

If you are coming from a OOP language like Java finding struct in Go might make you relieved. Although it is possible to do most OOP like things in Go. It is not the Go way. Structs are not objects. Structs are values. Struct are a collection of fields.

type Circle struct {
    X      float64
    Y      float64
    Radius float64
}

Here we have defined a struct type Circle that has 3 fields. To use a struct we can declare a new Circle variable like any other type.

c1 := Circle{
    X:      15.0,
    Y:      12.0,
    Radius: 8.5,
}

c2 := Circle{15.0, 12.0, 8.5}

These two are identical definition. Notice in c1 we put the field name and in c2 we omit it. We can only omit field names if a) we initialize all the fields and b) we omit all the fields. For example this is illegal

c2 := Circle{15.0, Y: 18.0, 8.5} // This will not compile

Accessing Fields

If a struct has exported fields and methods, we can use it in any other package after importing the package. We can not use unexported method or fields outside the package. To use a field or a method on a struct type we can use the . notation.

fmt.Println(c1.X, c1.Y, c1.Radius)

Methods

We talked about function in a previous post. Methods are just like functions but with a receiver argument.

func (c Circle) Area() float64 {
    return c.Radius * c.Radius * math.Pi
}

func Area(c Circle) float64 {
    return c.Radius * c.Radius * math.Pi
}

You can think of func (c Circle) Area() float64 as the same as func Area(c Circle) float64. In the Area method we will have a variable c of type Circle in scope, so we can use the value.

Receiver vs Pointer Receiver

We can declare methods with pointer receivers. Pointer receivers can be a bit confusing at times. You may think if you have a pointer receiver method defined you won't be able to use that method on the value of the struct. That is not the case. One of the main reasons you would want to use the pointer receiver is to mutate the value the other would be if the value is two large and value receiver would have to make a big copy operation. This StackOverflow Answer outlines it in much more details.

func (c *Circle) Area() float64 {
    return c.Radius * c.Radius * math.Pi
}

func (c Circle) Area2() float64 {
    return c.Radius * c.Radius * math.Pi
}

We can use the function as such

fmt.Println(c1.Area() == c1.Area2())

Embedded Structs

In Go we usually do no promote the idea of inheritance. In OOP inheritance is the concept of one type inheriting its methods and fields from another type. Instead what we do have is embedded structs. In Go we try to compose as much as possible. We embed a struct in another by not adding a name to it.

type Wheel struct {
    Circle
    Material string
    Color    string
    X        float64
}

With struct embedding we can use the methods and fields of Circle type from Wheel as if they were defined on the Wheel type.

w1 := Wheel{
    Circle: Circle{
        Radius: 10.0,
        X:      15.0,
    },
    Material: "Rubber",
    Color:    "Black",
    X:        5.0,
}

fmt.Println(w1.Area())

Shadowing Embedded Structs

Let's take another look at our Wheel type.

type Wheel struct {
    Circle
    Material string
    Color    string
    X        float64
}

We have a field X of type float64 defined on Wheel. We also have a embedded struct Circle which also have field X defined. What would happen if we tried to print w1.X. Would it print 15 from the embedded Circle type or 5 from X defined on Wheel type.

fmt.Println(w1.X) // 5

This will print 5. X in Wheel shadows the X field in Circle. We can still access the X in Circle by accessing fields using the . notation.

fmt.Println(w1.Circle.X) // 15

We can also shadow methods from embedded structs. We can embed any number of structs. Although this will make it harder to read our code.

The main difference between this type of composition and inheritance is that inheritance tries create a is relationship where composition create a has relationship.

Next Steps

This is Part 9 of this Go crash course series.

Go Crash Course Part VIII: if, switch and for

Mofi Rahman — Wed, 12 May 2021 01:57:33 +0000

If

In programming often we have to have conditional execution of certain statements. In most programming languages we have the idea of if.

var x = 10
if x > 5 {
    fmt.Println("x is greater than 5")
}

In this example we have a variable x which has value of 10. Then we check whether or not x is greater than 5. If it is, we print something. Otherwise we do nothing.

if - else if - else

Often we are checking for more than one related thing. Lets take the example of FizzBuzz problem. For any number n, we want to print Fizz if n is divisible by 3, Buzz if n is divisible by 5, FizzBuzz if n is divisible by both 3 and 5 and n if its not divisible by either 3 or 5.

if n%15 == 0 {
    fmt.Println("FizzBuzz")
} else if (n % 5) == 0 {
    fmt.Println("Buzz")
} else if (n % 3) == 0 {
    fmt.Println("Fizz")
} else {
    fmt.Println(n)
}

We can chain as many if-else if as we want. else is a special case where we do not have to have a conditional operator. It matches the case that no if - else if conditions match.

It is almost always possible to skip the else branch in functions. For example

func isEven(n int) bool {
    if n%2 == 1 {
        return false
    }
    return true
}

Instead of having a else block we can just return the default case.

If with statement

Sometimes we want to check some condition of variable we just created and we only need the variable for the condition. An example might help clear this up a bit more.

func minRand(min int) int {
    rand.Seed(time.Now().UnixNano())
    if v := rand.Int(); v > min {
        return v
    }
    return min
}

We have a random number v and if v is greater than min we return v if not we would just return min. We do not need access to v outside the if condition. This helps us with readability as well as variable naming. In go we are not allowed to redefine a variable with a different type. In a large function having every variable in the same scope might cause trouble.

For

In programming we sometimes need to do something multiple times. We achieve this using loops. Go has only one construct for looping. It is the for keyword. But for is pretty versatile in go where we do not need anything else like do-while, while like in some other language.

Anatomy of for

Generally a for loop has this structure

for i := 0; i < 100; i++ {
}

We have a init that initializes our loop invariant. Then we have a condition that is used to terminate the loop and we have a change that is run after each loop iteration.

All three of these are optional and can be used or omitted as we need.

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

for i := 0; ; {
    if i >= 5 {
        break
    }
    fmt.Println(i)
    i++
}

i := 0
for i < 5 {
    fmt.Println(i)
    i++
}

i = 0
for ; ; i++ {
    if i >= 5 {
        break
    }
    fmt.Println(i)
}

for i := 0; i < 5; {
    fmt.Println(i)
    i++
}

i = 0
for ; i < 5; i++ {
    fmt.Println(i)
}

for i := 0; ; i++ {
    if i >= 5 {
        break
    }
    fmt.Println(i)
}

i = 0
for {
    if i >= 5 {
        break
    }
    fmt.Println(i)
    i++
}

These are all possible combination of a for loop with a single invariant. All of these for loop do the exact same thing.

Break

At any point in the for execution we can use the break statement to break out of the closest for loop.

Mutli invariant for loop

We can also have for loops where we have two variables.

for i, j := 0, 10; i != j; i, j = i+1, j-1 {
    fmt.Println(i, j)
}

The basic structure is the same. We have a init where we initialize i and j. Condition to chech i != j and then we increase i and decrease j.

Forever

If we run a for loop with no exit condition we runt he for loop forever. There are times we want to run a process indefinitely.

for{
// do work indefinitely 
}

For example if we look at the source code for net/http we can see an example of indefinite for loop that waits for new connection to server.

Next Steps

This is Part 8 of this Go crash course series.

Go Crash Course Part VII: Functions, Closures and Defer

Mofi Rahman — Tue, 11 May 2021 06:20:01 +0000

Functions

We talked about functions in some detail in a previous chapter. But lets cover some more features of functions these time. Functions are first class citizens of go syntax. This means functions are like any other types and can be passed to other functions and returned from functions. But one more thing we can do with function is define function types.

type HandlerFunc func(ResponseWriter, *Request)

The above is from actual source code of go pkg net/http HandlerFunc

Being able to create type definitions on functions is awesome. One of the main reason we would want to do this for is it lets us write less code.

func takesFunc(func (int, string, bool) (bool, error)) int

//vs

type CrazyFunc(int, string, bool) (bool, error)
func takesFunc(c CrazyFunc) int

Between the two, I would argue the later is more readable and and glance-able. Anyone jumping into the code base can easily know what contract takesFunc needs to fulfill. Also if we have multiple functions that takes the CrazyFunc as an argument we end up writing less code. Its a win-win.

But the more important benefit of being able to define function types is that we can attach methods to functions. We have not talked about methods yet (We will learn more about methods when we talk about structs), but in short methods are functions attached on a specific type. We denote something as method by using a receiver argument that appears between the func keyword and function name. Being able to define methods are really powerful because it lets us implement interfaces with functions. Like the example of the HandlerFunc function. We attach a method ServeHTTP That calls the function itself and now our HandlerFunc implements the Handler interface which is needed for building http servers.

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r)
}

Now in our code where we needed to pass a handler like in the Handle method from *http.ServeMux we can send any function with the same signature as HandlerFunc type casted to HandlerFunc.

In practice we probably will use the HandleFunc method that does the casting for us. But its possible.

If you did not understand everything we talked about here do not worry. This is meant to give you a quick glimpse of what is possible. We need some more basic knowledge to be able to utilize all of these properly.

Closures

Before we can understand closures we need to understand anonymous function.

Anonymous Function

Anonymous functions as the name suggests are anonymous. They are functions that does not have a name. In go we can define a function inline as a variable or as a return.

adder := func(a int, b int) int {
    return a + b
}

Closures

Closures are anonymous function that refer to variables defined outside the function scope. The scope has to be valid for the function.

func counter() func() int {
    i := 0
    return func() int {
        i++
        return i
    }
}

In this example we have a function counter that returns an anonymous function which refers to variable declared in counter. So the inner function that we return is a closure.

In our code we can use this function

counter1 := counter()
counter2 := counter()

fmt.Println(counter1()) // 1
fmt.Println(counter2()) // 1

We have created two independent counters that will grow every time they are called. A counter is probably a pretty dumb example for closure but I hope it gets the point across. There is this amazing article by Jon Calhoun that goes into even more depth where closures can be utilized to improve our code.

Defer

In Go the defer keyword is used to postpone the execution of function until the surrounding function returns.

func deferredPrint() {
    defer fmt.Println("defer 1")
    fmt.Println("regular thing")
    defer fmt.Println("defer 2")
}

Executing this deferredPrint will print

regular thing
defer 2
defer 1

There are two key observations here. First, our fmt.Println function call without defer executed first. This makes sense because defer postpones the execution of the other function calls until we reach the end of the function. Second, the print from our defer functions seems to be in reverse order. This is not random. Every defer we have will execute in reverse order.

Defer is particularly useful when we want to take some action no matter what happens, like closing a db connection or closing a file. Defer is also useful for panic recovery. We have not talked about panic yet. Usually its never a good idea to panic in our program but there are cases when its appropriate. We will talk about panic in details in a later chapter.

Next Steps

This is Part 7 of this Go crash course series.

Go Crash Course Part VI: Blocks, Scopes and Shadowing

Mofi Rahman — Fri, 07 May 2021 07:15:58 +0000

Blocks

In go a block is defined with a set of {}. Usually when we create a function we are in a block already. But we can define a block pretty much anywhere.

i := 10
{
    i := 5
    fmt.Println(i) // i is 5
}
fmt.Println(i) // i is 10

Scope

Scope defines where certain variable would be defined in. A scope can be block scoped, function scoped or package scoped. Each scope encompasses the previous. A package scoped variable would be available to the function and block but not the other way around.

x := 10
var z int // z declared here
{
    fmt.Println(x) // this is fine
    y := 15
    z = 20 // defined here 
}
fmt.Println(y) // this is not fine
fmt.Println(z) // this is fine

Shadowing

We can shadow any variable that is defined in the outer scope.

x := 10
{
    x := 15
    {
        x := 20
        fmt.Println(x) // 20
    }
    fmt.Println(x) // 15
}
fmt.Println(x) // 10

Just block level shadowing is uncommon. There are rare use cases for this. But I haven't found really good use case for block level shadowing or even for blocks for that matter.

Next Steps

This is Part 6 of this Go crash course series.

Go Crash Course Part V: Constants, Operators and Reserved Keywords

Mofi Rahman — Fri, 07 May 2021 06:31:02 +0000

Constants

In a previous post I said go does not have immutable types. I was only half right. Go does have constants denoted with const but its not comparable to final in Java or const in JavaScript because const in go only works with basic types and for things we can know in compile time. Like boolean values, integer, floating point, characters, runes and strings. We can not create constants of composite types like struct, func or interface. All values must be known at compile time. You could store almost any arbitrary numeric constant in a untyped const. The problem happens when you try to use the value.

const (
    BigConst = math.MaxFloat64 * math.MaxFloat64
)

If you have this at the top of your go code and compile the code. It will be fine. But if you try to print this or try to cast

fmt.Println(BigConst) // this code wont compile

This code won't compile because BigConst won't fit in a float64.

iota

We can generate a series of constants with iota constant generator.

const (
    a0 = iota // 0
    a1 = iota // 1
    a2 = iota // 2
    a3 = iota // 3
)

We can also use the shorthand by skipping assignment to set values for a series of constants.

const (
    b0 = iota // 0
    b1        // 1
    b2        // 2
    b3        // 3
)

If we skip one or two value the iota generator continues counting.

const (
    c0 = iota // 0
    c1 = 43
    c2 = 75
    c3 = iota // 3
)

I can't imagine a scenario where this will be useful though. But it's there.

iota generator is reevaluated per const block.

const d0 = iota //0
const d1 = iota //0
const d2 = iota //0
const d3 = iota //0

const is uses almost like enum in other languages or for mathmetical constants.

Operators

Go supports a number of operators. Some of them are arithmetic operators. Some are punctuation. Other have specific meaning based on context.

+    &     +=    &=     &&    ==    !=    (    )
-    |     -=    |=     ||    <     <=    [    ]
*    ^     *=    ^=     <-    >     >=    {    }
/    <<    /=    <<=    ++    =     :=    ,    ;
%    >>    %=    >>=    --    !     ...   .    :
     &^          &^=

The official language spec talks about each of the operator in great details.

Operators that are used for calculating values have a set precedence order. Operators of same precedence get evaluated left to right.

Precedence    Operator
    5             *  /  %  <<  >>  &  &^
    4             +  -  |  ^
    3             ==  !=  <  <=  >  >=
    2             &&
    1             ||

For example

x := 5*10 + 6/3 | 7%4&15 
// (5*10) + (6/3) | (7%4)&15 => 50 + 2 | 3&15 => 52 | 3 = 55

This evaluates without ambiguity. But this is a classic example of just because you could, does not mean you should. This is not easily human readable. Using proper brackets will increase readability.

Reserved Keywords

Go has a fairly small set of reserved keywords. Other languages has a fairly large reserved keywords. c++ 95, Java 53, JS 64 etc. Go has only 25 reserved keywords. Reserved keyword mean in the syntax we are not allowed name anything with this names.

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

Having such a limited set of keywords has some drawbacks too.

As you can see none of the types are actually part of the reserved keywords. So one can create a variable called int. Now if we try to create a variable of type int, it won't work.

int := 10 // this is valid code
var c int = 10 // this doesnt work now

Next Steps

This is Part 5 of this Go crash course series.

Go Crash Course Part IV: Types, Conversion and Inference

Mofi Rahman — Thu, 06 May 2021 03:11:59 +0000

The code for this part is in the types folder under this github repo.

Types

Go is a typed language. That means everything we create must have a type.

There are a few basic types.

Boolean Types

Represents set of boolean value. With predefined constant true and false

bool        true or false

Numeric Types

Integer and Floating point values. Following are architecture independent numeric types.


uint8       the set of all unsigned  8-bit integers (0 to 255)
uint16      the set of all unsigned 16-bit integers (0 to 65535)
uint32      the set of all unsigned 32-bit integers (0 to 4294967295)
uint64      the set of all unsigned 64-bit integers (0 to 18446744073709551615)

int8        the set of all signed  8-bit integers (-128 to 127)
int16       the set of all signed 16-bit integers (-32768 to 32767)
int32       the set of all signed 32-bit integers (-2147483648 to 2147483647)
int64       the set of all signed 64-bit integers (-9223372036854775808 to 9223372036854775807)

float32     the set of all IEEE-754 32-bit floating-point numbers
float64     the set of all IEEE-754 64-bit floating-point numbers

complex64   the set of all complex numbers with float32 real and imaginary parts
complex128  the set of all complex numbers with float64 real and imaginary parts

byte        alias for uint8
rune        alias for int32

These are architecture dependent. (Could be either 32 bit or 64 bit)

uint     either 32 or 64 bits
int      same size as uint
uintptr  an unsigned integer large enough to store the uninterpreted bits of a pointer value

String Types

String is a sequence of bytes.

Composite Types

Array

Arrays are fixed length and fixed type.

var arr = [5]int{}

Slice

Contiguous segment of underlying array. Has fixed type. Length can be dynamically reallocated. (More on this on a later chapter)

var slice = []int{}

Maps

Key value store. Similar to dictionary in python or object in JavaScript. But it still has a fixed type.

var maps = map[int]int{}

Functions

Functions are also types.

var function = func() int {
    return 42
}

function has a type func() int

Struct

Custom type defined by user. Its a sequence of named elements with name and types. Struct can be empty too.

type empty struct{}
var x = empty{}

Channel

Channels are typed conduit between running go routines. We will hold off on talking about channels until we talk about go routines.

Interface

An interface type specifies a method set called its interface. If a any type has the method set of the interface, that type implements the interface. All types implement the empty interface interface{}. Interface does not have any type. Its always the underlying components type. A type can implement any number of interfaces. We will talk about interface in great details in a later post.

var y interface{} = x // y now has a type of empty since that is the type of x.

Type Alias and Type Definition

We already saw 2 examples of type aliases. byte and rune are type aliases of uint8 and uint32 respectively. This means every time we use byte we are basically using an uint8. We can also define our own type from another base type.

// type alias
type myFloat = float64
var aliasFloat myFloat = 5.0 // has type float64
// type definition
type myint int
var aliasInt myint = 1 // has type myint

Type alias is useful for moving types between packages for refactoring. Lets say we were using a struct type called coolstuff in a package. If we move the coolstuff to a different package, we would have to refactor all the places where coolstuff were being used. One way to mitigate issues during the refactor type is to create a type alias in the old package where coolstuff was.

type coolstuff = newpackage.Coolstuff

Type definition is used usually for creating enums. Or sometimes to extend existing types by attaching methods. For example:

func (m myint) double() myint {
    return m * 2
}

Type int does not have any methods. But with myint we can create a double() method on our type. We have yet to talk about method and method receiver. We will talk about it in depth.

Type Conversion

Basic numeric types can be converted with T() syntax. Where T is the type to be converted to.

var i int = 355        // type int
f := float64(i)        // type float64
by := byte(i)          // type byte (uint8)

Struct type can be converted to and from each other as long as they have identical field names and types in identical order.

type person struct {
    age  int
    name string
}

type student struct {
    age  int // try swapping these fields
    name string
}

p := person{age: 20, name: "john"}
std := student{age: 15, name: "paul"}

p2 := person(std)
s2 := student(p)

There is a way to type case any struct to any other struct using the unsafe package. This is rarely used. If you write code that uses unsafe package, you better have a solid reasoning for it.

On function calls type conversion is automatic if the parameter can be converted to the desired type it gets converted. int will be converted to float but not the other way around because float to int can loose precision.

For defined types, the conversion is uni directional. You can always use the underlying type in place of the defined type but not the other way around.

func definedTypeConversion(mi myint) {
    fmt.Printf("Type of mi=%T\n", mi)
}

func takesInt(i int) {
    fmt.Printf("Type of i=%d", i)
}

definedTypeConversion(aliasInt) 
definedTypeConversion(5) // this get converted to myint type

takesInt(5)
takesInt(aliasInt) // this does not work

Inference

We have seen example of inference a few times already. Every time we use the := operator, we are inferring the type of the left hand operand.

x := 5 // type inferred to int
y := x // type inferred to int because of the type of x

Type inference also happens for numeric constants when passing to a function if the compiler does not detect a loss of precision or overflow.

Next Steps

This is Part 4 of this Go crash course series.

Go Crash Course Part III: Variables and Functions

Mofi Rahman — Wed, 05 May 2021 01:21:02 +0000

Variables

In Go using the var keyword we can declare a list of variables of same type.

var a, b, c int

Variables are mutable types. Go does not support immutable types. (Go does have constants but they are not the same as immutable types). We can also define variables in the global scope. Once a variable is defined it can be used in its scope.

Scope is where a particular variable is valid. We will dive much deeper into scope in a later chapter.

If we do also declare the variable the same time we define it. We can also declare a variable without defining its type. For simple types

var a = 10
var b int32 = 26

As we can see we can create variables with type declared and not declared. When we don't declare type, the type is inferred. Type inference always chooses the default type for value. For example

var a = 10 // int
var b = 1.5 // float64

We can also use short variable declaration.

short := 10

One thing to note though, short variable declaration can not be used in global scope.

Naming Variables

Has to start with Alphabets or _ count or _data or _1
Should be Camel Case userID
Short names preferred over long

This Talk from 2014 sums it up nicely.

Shadowing

Any variable defined in an outer scope can be shadowed by a new variable in inner scope. When shadowing we can also change type of variable.

Function

We already saw some examples of functions. Our func main was a function. It is a special type of function. There is another special type of function. It is the init function.

init

init function gets executed before anything else in the package. We can also have more than 1 init function per package. All the init functions will execute before anything else in the package. If we have init function in multiple files in the same package, init function is executed in lexical file order.

For example in our git repository change directory into functions folder.

We have 3 files in there. a.go, b.go and main.go we have a total of 5 init functions. 3 in main.go and 1 each on a.go and b.go.

cd function
go run *

We would see

init from file a
init from file b
hello from init 1
hello from init 2
hello from init 3
Hello World

This information should not be something we rely on while building application. This would be a terrible practice to build software on such assumption.

main

main is the entry point to our application. After all init steps has finished execution of main begins. We can have only one main function per application. And main package can not be exported or imported by other.

Other than main and init users have free reign to define
any functions in go.

Anatomy of functions

func <funcname> (0 or more parameters)(0 or more return types) {

}

Function has a name. It can take 0 or more parameters and it can return 0 or more things from a function.

For example:

func Greet() {
    fmt.Println("hello")
}

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

func Divide(a, b int) (int, int) {
    return a / b, a % b
}

Named returns

We can also have named return. Named returns can be useful when we have multiple returns and its not immediately clear what the values represent when returned.

func NamedDivide(a, b int) (quotient int, remainder int) {
    quotient, remainder = a/b, a%b
    return
}

In the previous Divide function. We had to look at the code to figure out that the first response was the quotient and the second was the remainder. In this example the function definition makes it super clear. We probably won't even need any more documentation.

Naming functions

Same rules as variable naming apply.

Functions are values

Functions are first class citizens in Go. That means we can create variables that are of type function. As well as pass functions as function parameters and receive function from function return.

func TakeFunc(take func() string) {
    data := take()
    fmt.Println(data)
}

func GiveFunc() func() string {
    f := func() string {
        return "give"
    }
    return f
}

Overloading

Go does not support function overloading. That means we can not have two function that has the same name but different signature. But we can always shadow a function in inner scope.

For example we can define a new function in main called Greet. Now when we use Greet() we are using the inner function.

Greet := func() string {
    return "shadow outer Greet"
}

Next Steps

This is Part 3 of this Go crash course series.

Go Crash Course Part II: Package, Import and Export

Mofi Rahman — Tue, 04 May 2021 07:42:35 +0000

Package Scope

We structure our code in packages. We also import other packages from standard library and external sources. In the last application we had only one file main.go. But we could also have more than one file in our application. All the files in the same folder level are in the same package. All variables and functions in the package scope are shared.

If you haven't already clone this repository from Part 1

# from the root of the repository.
# if you are in any folder change directory to root
cd packaging

The folder structure of packaging folder looks like this

.
├── file1.go
├── file2.go
└── main.go

The content of the files are following.

// main.go
package main

import "fmt"

func main() {
    fmt.Println(data1, data2)
}

// file1.go
package main

var data2 = "world"

// file2.go
package main

var data2 = "world"

The files does not have much things. But it will be enough to demonstrate.

Lets try to build it again.

go run main.go

We get an error.

# command-line-arguments
./main.go:6:14: undefined: data1
./main.go:6:21: undefined: data2

Huh! I said just a moment ago that the variables in package are shared. But this is saying the variables are undefined. What could this be.

The problem is actually with our go run command. We are telling go to run the main.go file. But it is not the only file needed for our application to work. We need to let go build tool know that it needs to include the other files too. We can do one of two things

go run main.go file1.go file2.go
#or
go run *

We will talk about how to build packages for external use in a later chapter.

Import

We can import any standard library packages by putting them at the top of our file. If we have more than one import we can add multiple import statements or putting in an import block.

import (
    "import1"
    "import2"
)

There are many packages in the standard library. You can find them here. These packages come bundled with Go runtime.

But what if we want to use a package that is not part of the standard library. We will use Go modules for that.

Go modules are the way we manage dependencies in our Go application. It is comparable to package.json for node or requirements.txt for python.

You can create a new module with go mod init <modulename>. To download a module we run go get <modulepath>. This updates our go.mod file with the module. If you clone a repository with a populated go.mod file. You can download the necessary modules with go mod download.

From the root of the repository

cd importing
go mod download
go run main.go

We should see on our terminal some thing like this print.

hello world
{"level":"debug","time":"2021-05-04T02:43:23-04:00","message":"hello"}

Exporting

Exporting can mean two different things. One is package level export. Exporting local packages to be used in other local packages. And the other is exporting our amazing library for the world to use. When you are building a Go application that you expect other people to import use the module path that represents the git repository. For example if your code is going to github.com/username/pkg name the module as github.com/username/pkg

In our example our code will be living in github.com/moficodes/go-crash-course/exporting so we create a new module in the exporting folder with that name. We have another folder called print with a file print.go and package print. The file structure looks like the following.

.
├── go.mod
├── main.go
└── print
    └── print.go

We can import this print package in the main package with

import "github.com/moficodes/go-crash-course/exporting/print"

In our main function we try to use two variables defined in print package.

// print/print.go
package print

var data = "hello"
var Number = 1

If we try to run our application from exporting folder:

go run main.go

We would see:

# command-line-arguments
./main.go:10:14: cannot refer to unexported name print.data

What just happened? We got an error about one of the two variables defined in our file as not being exported. But we did not put any special instruction to export either of those variables.

In Go anything that starts with an uppercase letter gets exported. This is different from languages like Java or JavaScript where you have to explicitly declare something being exported. This is pretty nice because the language semantics actually carry meaning.

The same uppercase rule is true for imported packages too.

Next Steps

This is Part 2 of this Go crash course series.

Go Crash Course Part I: Introduction

Mofi Rahman — Tue, 04 May 2021 05:50:44 +0000

Go

Go is an open source programming language known for its simplicity and ease of use. It has great concurrency primitives. I have been an user of go for about 4 years now. I will try to collect things I have learned over the last few years to help you get GOing (pun intended 😄!)

Installation

Go is available to download for all OS.

Instruction for installing go is here

If you are Mac user you can use brew to install Go.

Go features

There are many programming languages out there. Why would you choose go? I think there are a few reasons why Go can be very useful.

It is compiled. So small binaries and great for building containers.
It is fast. Probably not as fast as c/c++ or rust, but for most use cases Go is faster than Java, Python or JavaScript.
It is simple. Although this is fairly subjective. But for most people familiar with any other language getting comfortable with the go syntax is a matter of days. The language does not have too much things. So the learning curve is not too steep.
The standard library is very good. For most thing you want to do with go, you don't have to go looking for external libraries. The standard library does an excellent job in giving us the tool we need. For the things we need to use libraries for we can find it here
The community around go is one the best around. From the Go team to the advocates of Go, I find the people very welcoming and helpful.

Get Coding

Talk is cheap, show me the code.

package main

import (
    "fmt"
)

func main() {
    fmt.Println("Hello, World")
}

All Go source code is organized in package. For the entry point of our application we use package main. Our code execution starts at func main. That is also how we define a function in Go. Go code executes in sequence. All our import are at the top of the file. In this example we are importing the fmt package. fmt package has many io related functions. We use the Println method to print to console.

We can access the source code for this here

git clone git@github.com:moficodes/go-crash-course.git
cd hello-world
go run main.go

If you don't have your ssh keys setup in Github you can also clone using https. But ssh is preferred.

We should see it output Hello, World in our terminal.

Next Steps

This is Part 1 of this Go crash course series.

Learning while Having Fun

Mofi Rahman — Thu, 13 Feb 2020 23:59:43 +0000

As a developer advocate I feel like its my job to be learning new things so I can make them easier for my audience. This constant act of learning can take its toll. And learning for just learnings sake is extremely difficult. But when I am starting with a new piece of technology often there is a bit of work required before I can start feeling confident to do something useful.

Today I am writing about one approach I found extremely useful. Learning while having fun. And the thing I was learning was Ringcentral api. I was looking for a service to send some messages. I am quite familiar with the twilio sdk and have used it for few of my projects before. But I knew Mike Stowe worked for Ringcentral. And I luckily bumped into him at Developer Week 2020. In their platform of learning and engaging with Ringcentral they have gamified the entire process of learning about their tech stack. Points for reading article as well as finding out where to find info if and when I would get stuck. Doing silly little photo challenges all made it enjoyable to do the tasks. The instant gratification of doing something and getting some points for doing it was great.

I tried their Javascript SDK to test out sending a message to my phone and it was as easy as setting a new project up with a few lines of config and voila I had a message to my phone.

They have a good number of language SDKs to choose from.
Getting Started with Starter Code

As of writing this article they did not have docs for Golang. But they do have an SDK. So I can integrate that into my application.

I think I will play with this a bit more. But so far it looks like it does all I need it to do anyway.