Introduction

An open source Programming language created at Google.

Created as an internal programming language for Google infrastructure.

Go is simple, minimal and progmatic

Emphasis on solving practical aspect.

Modern General purpose language

Go is widely used for building backend systems
Build System based applications as well as Infrastructue Tools like docker,Kubernetes,Terraform.
Build for large scale backend and distributed systems
Rust can be used for Systems level applications but it is complex but performs slightly better than Go.

Statically typed language with high productivity.

We specifically provide the data type.
Easy to debug

Compiles to Native machine code

It complies quickly as compared to Other languages.
Java compiles to intermediate byte code.
We don’t need to package compiler separately.

Garbage collected language

Garbage collection is done automatically, which cannot be controlled manually.

Inbuilt concurrency

Can Leverage Multiple CPU cores
Run autonomous jobs Independent of each other

First appeared in Go 2009
Gopher is the mascot of Go
Go 1.0 was Released in March 2012
Current version is 1.26
Set up the development environment

Download and, install Go: https://go.dev
Create a GOPATH envirnoment variable

'export GOPATH=$HOME/go' >> ~/.bashrc

Set the GOMODCACHE environment variable (Eg: export GOMODCACHE=$HOME/go/pkg).

The directory where third-party libraries will be dowloaded
export GOMODCACHE=$GOPATH/pkg
The default location of the module cache is $GoPath/pkg/mod. To use a different location, set, the GOMODCACHE environment variable.
The module cache Is the directory Where the Go command stores Downloaded module files. The module cache Is distinct from the build cache Which contains compiled packages and other build artifacts.

Setup following environment variables

GOMODCACHE=$GOPATH/pkg
GOBIN=$GOPATH/bin

Set the GOBIN environment variable - The directory where go commands will place binaries (executables)

export GOBIN=$GOPATH/bin
go install - Installs executables into GOBIN directory

Add GOBIN to system path

echo 'export PATH=$PATH:$GOBIN' >> ~/.bashrc

Install GIT: https://git-scm.com
Install an IDE, VS Code: https://code.visualstudio.com or use GoLand(https://www.jetbrains.com/go/)

GOLand is a dedicated ID

Check Installation with following commands

go env GOMODCACHE
go env GOBIN
go env
go version

Starting up project

create a root directory for your project
Use command go mod init "{module_name}" to create a go.mod file

This is a dependency management file
This includes any third party libraries which we intend to use in our project.
It is a mandatory file even if we don't use any dependencies.
Use command go mod init "{module_name}" to create file

In Linux Go Installation path is

/usr/lib/golang

Go has an opensource eco system.

No License required for any libraries.

Disadvantages

It is not a very much feature rich programming language.
C an C++ can perform bertter than go under certain conditions but Go performs better than Java and C#.

In Go, we give two kinds of package names, either main or any other name.

Main means It compiles to executables.
Any name, other than main Then it is a library.

Add import block and add libraries

Standard libraries which are installed with Go.
Third-party libraries Which are imported from vendors.
Import defines the import block to import libraries

Main is the entry point to executable programs
Library packages Do not include main
Go build command compiles all the “.go” source files from the directory and put the resulting binary into the same directory.
To change the name of executable Use -o command

Go build -o “{Executable – name}”

To create another Operating System specific build file use GOOS=Windows GOARCH=amd64 go build.
Multiple main functions are not allowed.

There should be only one entry point

The executables created from Go do not need to install Go in another environment to run. These already contain some essential Go environment aspects.
Go executables are very lightweight

Very low and lightweight operating systems(Linux distribution) Have been created with Go. These require very less memory.

Go install creates a build And install executables In GOBIN location.
Go run Is used to run a Go file during development phase. It does not create a build file.

We should always specify a file name with Go run command.
It create an executable at temporary location.
We can specify multiple files in Go run command.

We can pass multiple files to run command.
Add GoBin To system path So that executables can be run From any location.
Go fmt formats code To resolve formatting issues during copy and paste.
Go clean cleans/deletes the executables From current directory.
Declaring variables in Go

Var {var_name} string
Local variables have a local scope that is scope is limited to function block only.
Package levels variable have scope within the package.

Package is a directory Where we organise source files.

The keyword var Is used to declare variables
Inside the functions, short assignment operator (:=) Can be used to declare and initialise variables without using var and datatype.
Short assignment operator (:=) Can’t be used for declaring package level variables.
The keyword const is used to declare constant variables.
Go doesn’t provide enum So we have to use some constant mechanism to build enumerate.
Short assignment operator is only needed at the time of declaration. When we reassign value to Variable Defined by short assignments, operator, we should not use the same.

Loops

There is no do while, while loops only for loop is there.
An empty for loop Is an infinite loop.
We can use for loop with only one statement as condition.
We can exit from loop using break, We can skip in a loop using continue.
In switch case Break is not mandatory in each case expression.
There is a Range loop Specifically to iterate over Collection.
There is break And continue via which we can control loops.

We use func keyword to write Functions.

Go functions can return multiple values.
An empty interface in arguments supports any data type.

There is No void keyword

No datatype Needs to be mentioned for void return.

We specify The data types in parenthesis when a function returns multiple values.
We must maintain order while returning values.
For a single data type parenthesis is not required.
Functions can have Variadic parameter by using (“…”) syntax.

Variadic parameter Is used to pass Variadic Number of values.
The last parameter in Go can be a variadic parameter.
We cannot have multiple variadic parameter.
Variadic parameters are data type specific.
In Variadic parameter We can pass many number of parameters.
Variadic parameters are indexed from 0 to n number of values.
For range loop is used to iterate over a variadic parameter.
We can also pass a collection in place of Variadic variable.
It is used when values are optional.
If we pass nothing in a Variadic Number nothing is sent.

Go support anonymous functions.
In Go There is no try catch mechanism. It has a built in data type called as error. This is used to handle errors.
Most functions Latest returned value is an error value. The caller function checks If the error value is NULL or not To check successful execution.
If we do not want to return a value in a case, we can return “-“ underscore. An underscore Is a blank identifier In Go.

This means in place of second identifier We are ignoring the values.
Blank identifiers (“-“) Are ignored by the compiler and compiler shows No error on them.

There are no warnings in Go. There are only compiler error.
Array, Slice and map are also called as composite types.
Slice is a dynamic array in go.

The difference between variadic parameter And dynamic array Is for dynamic array We should always pass a value.
In a Variadic parameter We can also pass a zero number of values Which we can’t do in a dynamic array.

Functional Go

Functions are values in Go
They can be assigned to a variable
Such an assignment is called as function value.
A closure is a function value that references variables form outside the body.
The function may access and assigned to the reference variables, in this sense, the function is “bound” To the variables.
The logic in a Closure function Is given by Caller function.
Functional programming is based on immutable data structures. No mutable data, no state(or implicit state).
Functions are first class citizen in the go programming language.
Go functions are like values
Go supports higher order functions.

Takes one or more function as parameter’s.
Functions can return functions

Go supports closure a function value that references Variables declared outside its body.
Go is not a functional programming language, but can Leverage its capability.
We can also pass functions as parameters.

Every go source file must start with a package main.
When we are using multiple source files dependent on each other we must specify all of them in a go run command or use "go run ." to run all files.
Go provides three types of data structures to work with collection

Arrays all fixed length collection

Array is a value type data structure.
We can use any type of the type in array. That is it can be user defined, primitive or collection type.
All values in an array are initialised to default values.
Array is fixed length data structure which is its limitation.

Slices a dynamically sized collection

Slice is a dynamic array built on top of normal array.
Slice is a three field data structure

Has a pointer that points to an underlying array
Length specifies the length of an underlying array.
Capacity specifies the capacity of the array.

Slices can be enlarged at any time using built-in function append().
A built-in copy function can be used for creating bigger slices by copying contents from existing slice.
Slice is completely a go specific Data structure not found in other programming languages.
Capacity is an optional property of slice which specifies pre allocated memory block.
Pointer points to an array.
Length is the length of underlying array.
Whenever performance is critical. We use the capacity parameter here allocation becomes quick.
By default, both length and capacity will become same while initialising.
In slice we may not give length while declaration.
A nil slice is a slice which has been declared but not yet initialised.

Capacity is not mandatory while declining/initialising slice.

Slice can be initialised either by using make function or by using literal expression.

We can also specify index-based values while initialising a slice.

We can also pass a variadic parameter in append.
We can also pass another slice in the append method.
Slice represents a sliced part of data where inner bound starts with one.
We can remove the inner and outer bound to get entire data from a slice for example copy_slice=slice[:]

Maps is a collection of key/value pairs.

Go provides a built in map type that implement a hash table.
Map is a collection of Key/value pair, which is an unordered collection.
The built in delete function removes An entry from the map for the given key.
Map provides a faster data revival for a Given key.
To iterate over the contents of a map Use the for range keyword.
A hash table is an unordered collection of key value pairs.
Every element/Memory block is uniquely identified by the key and the memory blocks Which are not in any order.

In array And slice There is an order of memory blocks.

Keys work like indexes
Reading is very fast by specifying unique key We can retrieve The value element in very faster manner.
Map is An unordered collection.
A nil map Is a map which is declared, but not initialised.
All the reference types must be initialised

Channel can only be initialised using make.

We can only insert data after initialising Our data structures.
For range iterator is used to iterate over a map.
We must provide data structure of both keys and values.
To retrieve Data from map, we can use one variable or 2 variable option.

With one Variable option, if keys exist The corresponding value will be retrieved. otherwise, default value will be received. There is no way to know if the value exist or not.

lan:=langs[“EL”]

With two variable option, which is a better Approach in first variable, we will get the value if the value exist or not. The second variable is a Boolean expression If key exist Boolean value is true else false value.

lan,ok := langs[“EL”]

For Insert and update We use same mechanism. If we overwrite a key That is Reassign value to a key It will be An update expression.
To check existence of a key retrieve it using 2 variable And check Boolean value.
While retrieving values They may not be An order in their, retrieval As it is an is unordered.
Keys are always unique in a map

Channel is another built data structure which is reference type.
Struct(interface) is a user defined datatype which can be a value or a reference.

Slice map and channel or a part of concurrency programming.
Slice and map are reference types, which must be initialised either by using built-in, make function or literal expression.
Slice,map and channel can be initialised using make function. We can initialise Slice and map using literals.
In Go, there is a function called as init()

init is executed automatically before Main()
It is used to initialise package level variables.

In Go, we have literal expression that is using curly brackets {} we can initialise a value.

When we do with array we call it a array literal.

We can specify/initialise values at specific index with array literal.

When we do with Slice we call it a slice literal.
When we do with a Map we call it a map literal.
We use literal assignments with short assignment operator.
We initialise all the values in a single expression.
We can also use a 3 dot("...") operator to specify length of a value. In this case, we do not need to specify numeric length specifically. It automatically takes based on number of elements.

Go provides very limited number of built in functions.
Default value of a string datatype is empty string.
We can use normal for loop to iterate over get data structures but better is to use for range expression.

We can use for range to iterate over only keys, only values or both key and values.
When using for range for only values we must use a blank identifier for keys.
For range can be used to iterate over array, slice, map, channel, variadic parameter.

Any unused variable is considered as a compiler error in go.
We must use a blank identifier in this case for example, while defining keys and values while iterating a list and only using values.
The built in append function check for available capacity. If it is less than required it dynamically. allocates them.

Available capacity is also referred to as pre allocated memory.

To write multi line expressions in Go, use a “,”
Defer keyword

The keyword defer is used to schedule a function call to be executed right after a function returns.
Defer keyword is used to defer/schedule a function call to the moment the srrounding function returns.
Defer is used to write cleanup code for example closing connections etc.
Defer function executes in a bottom up manner that is the function deffered last will execute first.
Defer executes in all situations even after runtime exception/panic etc.
All Defer statements are executed in bottom up manner.
We can have an inline defer function
Defer functions are executed in last in first out manner.
https://github.com/gauravmatta/golang/tree/main/basics/defer

Panic Function

The built in panic function is used to stop the execution that will provide a panic situation.
Panic function is used to throw exception and sop execution.
When we run our program any unhandeled exception will trigger the panic function.
The panic function stops the execution.
We check for error and then send the error in panic function.
Any type can be passed to a panic function.
Panic is used for throwing run type exception like File Not Found,Configuration Errors,Database Connections,Errors during bootstrapping etc.
Panic is not a good situation to have.
Panic is raised in scenarios where continuing execution further does not means any sense and needs to be stopped.
Use of Panic is optional.
Defer statements are executed in bottom up order before panic stops the execution.
Panic propogates to the caller and after that program stops execution.
https://github.com/gauravmatta/golang/tree/main/basics/panic

Recover Function

The built in recover function is called within a deffered function to regain control over a panicking function.
Recover is used to regain control over panic situation in defer functions.
The defer statements include a recover function.
Recover function returns a value provided by panic function.

We can operate on value and regain control.

In Recover also all the defer functions are executed.
After recover the execution resumes from the caller function after the called function statement.
Recover is mostly used in HTTP Requests on REST API systems.
Recovery mechanism is mostly for Runtime Exception.
Recover is used to prevent system crashes in particular situation so that other operations are not impacted.
In HTTP request each request is processed by a different handler so one bad request should not crash the entire system.
The runtime exception does not propogate to entire server and server will not crash.
In every request api service we use a panic recovery.
Panic recovery is only for run time, exception And not for all panic conditions.
https://github.com/gauravmatta/golang/tree/main/basics/recover

Error Handling

Error Handling Is used to manage exceptions.
Go doesn’t have a try Catch mechanism So it cannot throw errors to parent/caller functions.
Go takes errors As values just like functions.
Go provides a builtin data type called as error.

In case of error We create a variable Of type error And returned from function.

There is a standard library of errors in go.
This provides essential parameters to create error data type variable.
The library helps us to create different type of error objects.
Generally go functions, return error as The last value as they return Multiple data types.

Generally, the last return value is the error value sent.
This convention is followed by the most Go developer Community.
If there is no error We return a nil value for error.
All other values are specified before the error value.

The errors library Provides a function called as New.

When we pass string in the function It returns a data type of type error Which we can return from our functions
It is better to create a package level variable for error values If we have multiple error values.

We can also customise errors using errorf function in fmt library To send a custom error Message which has a %w verb Which stands for wrap and error With some context specific information. This helps us to wrap information With error.
We can check a condition on type of error Using “Is” Function in errors library.
We can unwrap the error Using unwrap Method in error library. This only works with wrapped error using errorf.

If the error Has not been wrapped the error returns nil value.

We may need to write much boiler plate code in Go.
Architecture of Go

Packages

Go programmes are organised into directories is called as packages.
Go provides two kinds of packages

Package main for which the resulting binary will be an executable, a shared library package to be used for other packages.

Package main should have an entry point main function
Packages are identified using their case for access.

Package identifier starting with upper case letter will be exported to all other packages.
Package identifers starting with lower case, letter will not be exported to other packages, but it will be available across the same package.

To modularise and organise our code, we need libraries.
Library packages, are reusable
We should not put entire code in package main.
Go uses naming conventions for public/Private accessibility identification
Packages can have init function, which can be used for writing initialising logic at package level. This will be involved before invoking main function.
The keyword import is used to import packages into Go source files.
Packages can be imported by providing an alias name.
Packages can be imported by providing _(underscore) as an alias name, which is used for importing a package just for invoking init functions
Third-party packages are installed using Go get command.
The Go module introduced in Go 1.11 as an experimental feature, has become an official solution for dependency management since Go 1.16.
Init function is used in both main package as well as library packages.
All the init functions are executed when other libraries are called in a package.

The order of init is not a matter of concern. It execute in order libraries are imported.

The import block can be used for importing Standard library package and third-party library package.
A library package is an independent unit, and it should not depend on other library packages.
We can import a package with An alias name.
Main packages compile into an executable.
Most of the code is in library packages. Only few code is in main.
If we want 2 executables We will create two main packages.
Package. Main only contains code to start the application. Main is basically an entry point With Some supportive code.
In a real world system, we have lot of packages.
When we write a library package, we give a package name, other than main.

We should use lowercase letters
_ Are not allowed
- Can be used in some cases.
Names should be short.
Plurals Should not be used.

The Go.mod file contains all the entries of third-party libraries.

These are automatically added once we add/use third-party libraries in our project.

Our Library Structure depends on our directory structure.

Generally Package name is same as directory name Of the file. Technically, we can have a different name. There is no problem in that.

All files in package, access package level variables.
Function names starting with Capital letters are accessible in the files that include that package.
We should create a separate directory in package for main.
While importing packages, we first import the standard library package, then we import the third-party libraries, then we import custom libraries. Between all these, there must be Given a line break.

Basically, we import library in three sets.

Module name in Go.mod file is our root name

we import libraries using {go mod}/Path to package of file.

We create different libraries for different business domains.

Separate library for database persistence.
Separate library for business logic.

These packages are called from another packages.
When we import our library package, optionally, we can have an alias name.

Alias Purpose is to give shorter name for reference.
Alias name Is written before the package.

We may in some cases have different package name, then directory name. The same should be used while importing package.
If we have provided alias, we should use it for reference. We cannot use the original name.
In order to use third-party library, we need to download or install using “go get package name”
Once we install a third-party library, its supporting libraries are also installed And added to go.mod.
To use it in our code, we import the same.
go.mod Is basically a dependency management solution’s for third-party libraries.
We can search for libraries on pkg.go.dev.
We have standard library package, SQL, which supports multiple databases.
A method/variable with same name cannot be repeated across multiple source files in a package.
Go.mod file is a part of Go module.
Go module is a dependency management, solution, for third-party libraries.

User defined type

Go type system provides two user define type types

Struct

It is used for creating concrete user defined types.
A struct Is a collection of named Fields.
Behaviour can be added to a Struct Type by specifying receivers.
There are two types of method, receiver, value receiver, and pointer receiver.
Methods receiver are not special, they are just functions.
Pointer receiver can be used for two scenarios

Mutates the state of types.
Type that need more memory.

We can have a struct Without properties, this is called as An empty structure.
Struct Tags

Struct Tag is used to create a metadata For each attribute to be used for some other package.
Struct Tag, lets you provide some meta data to be used for other packages, mostly for encoding packages.
REST API Communicates using json format or xml format.

Now a days All people use json format.

If we provide tagging information while defining struct Tag that information is used for encoding packages.

So we can provide information like json names To be used for an Attribute during json encoding.
We use packages like encoding/json and encoding/xml to define tagging information

Struct Is mostly used for encoding packages.
Jason must follow industry standards from http://jsonapi.org

Example all keys should be lowercase.

All the attributes of struct Must start from a capital letter to make them public and usable across Packages

tagging is used to bridge this name casing gap Between struct and json standards.
We can add attributes like omit empty To remove a value from json if empty.

Interface

It is used for specifying Contracts.
Interfaces, are behaviour contracts To concrete types, which that you define behaviour for your objects.
Interfaces are implicitly satisfied
In Go, explicit declaration of interface implementation is not required. We just need to implement the methods defined in the interface into our struct type To implement an interface type.
In object oriented programming, a protocol or interface is a common means for unrelated objects to communicate with each other.
Interface provide hidden implementation.
The bigger, the interface, the weaker, the abstraction

Go has no classes.
Methods can be added to any type.
Go has no inheritance.
Type stand alone by themselves, they just are and have no hierarchy.
Go type system provides type embedding, which allows us to embedded struct types Into other struts To create bigger types using composition.
Be conservative in what you send, be liberal in what you accept from others.
A structure is a lightweight class. A struct has a state Defined by its properties or fields.
A struct has operations Which define its behaviour and are declared as methods.
Struct datatype Isolate between property and behaviour.
Property and behaviour are defined in different bodies or files.
We define structs Only by using properties, methods are added later.
In Go struct Instances can be either value type of reference type.
Value type struct Use memory of the stack frame.

Once the function is completed, all memory is automatically removed.

In reference type, we have to manually write code for memory allocation and deallocation Of memory, Post usage.
With inheritance, we have Type hierarchy, in a long chain Of multilevel inheritance. As the chain expands, this can become complex, so Go does not support inheritance.

Go recommend composition over inharitance.
Composition is implemented using type embedding

We cannot convert between types in go.
There is no hierarchy/relationship between types in go.
We can only embed types in Go.
Type assertion is not possible in Go.
We can have any number of embedded types.
In the same file, we can have more than one structs Which may be embedded or not in each other.
We can mutate struct Properties using functions.
When we create a struct Receiver by value, each time we mutate A copy is created and mutated.
Value receiver always creates a Value/copy and modify the same.
Whenever we want to mutate We must create a pointer receiver.

Reference type of struct.

reference type are created by Garbage collector, and not stored in stack frame.
Reference types are destroyed by garbage collector, and not removed from stack frame.
Reference types are stored in heap memory.
In a reference, type copy is not created.
When ever we use a pointer in Go, we make it as a reference type.
Reference, types are managed by Garbage collector.
A copy is not created for mutation of reference types.
Whenever we want to mutate, a property Then that method must be decorated with a pointer receiver.
Go compiler has an escape analysis process, which can make decisions based on type of receiver that is pointer or value to be sent in a function.

We should Try to use reference types with pointer receivers.

Types that need more memory should also be represented with reference types for efficiency and better performance.
Creation of reference type is not cost efficient So they should not be used everywhere.

We need to allocate/deallocate resources Also, after use using garbage collector.

We can also create reference types using new built in function without initialising.
The value returned is reference to New zero value of that type.
The “new” built-in function allocates memory. The first argument is a type, not a value, and the value returned is a pointer to a newly allocated zero value of that type.

P1 := new(Person)

There are four types of literals in go

Array Literal
Slice Literal
Map Literal
Struct Literal

Struct Is used for concrete user defined type, whereas interface is used for abstract type.
In Go type stand alone by themselves, they have no type hierarchy
Interfaces

Interfaces are behaviour contracts
Interface types Provide contracts To concrete types , Which let’s you define Behaviour for your objects.
Interfaces are implicitly satisfied.
In Go, explicit declaration of interface implementation is not required. We just need to implement the methods defined in the interface into our struct Type to implement an interface type.
In object oriented programming, a protocol or interface is a common means for unrelated objects To communicate with each other.
For loose coupling between types, we should use interfaces or contracts.

This is based on Liskov substitution principal that is designed by contract.
A base class reference must be able to use reference to all derived classes Without knowing them.

Interface is a contract which has to be fulfilled by its implementation.
There is no implementation in interface.
In Go interfaces are implemented implicitly that is do not need to specify its implementation syntax. We just need to implement methods and interface is implemented automatically.

Interfaces, implicitly, satisfied

Interface provides hidden implementation.
The bigger, the interface, the weaker is the abstraction.
Be conservative in what you send and be in what you accept from others.
Any struct Implementing interface must provide a concrete implementation Of its methods.
We can switch between types of an interface wherever it is used.
We should always write loosely coupled code via interface.

A loosely coupled code Looks clean and is easily testable and maintainable

interface{}(Empty interface) Says nothing.
The keyword any is an alias to an interface.

Any refers to An empty interface.It does not have any behaviour contract.
fmt.println has a variadic any as a parameter Which lets It print anything.
Reflection package which helps us to know the type of a variable also accepts NMT interface.

All values(Numeric, String, array, Slice, map) are an implementation of Empty interface.
In new versions of Go, we see any keyword.
struct{}(Empty struct) Is a struct Type that has no fields.

empty struct Does not take any value for allocation.
Empty struct Is used in scenarios when we want to use an empty variable.

Empty struct Occupies zero bytes of storage.
Interface helps us to define code for single responsibilities.

Every struct That implement the interface is designed for a single responsibility.

Interface are open for extension, but close for modification as per open/close principal.
The client should not be forced to depend upon interface methods that they do not use. This is stated in interface segregation, principal.
Interface should depend and communicate on through abstraction.
Interfaces should be implemented as per solid principles.
interface makes it easy To manage our persistent code.
It helps to provide mock implementation and write unit test cases of our code easily.
Concrete implementation Is not easy to manage.
Using interface, we will be using the high-level abstract level code. Thus implementation is hidden from us.

The imports organised with standard libraries, First then a line break, Then third-party libraries , a line break And then our own libraries.
Accept interfaces And return struts.
Explicit dependencies: Methods and classes should explicitly require(Typically, through method, parameters or constructor’s parameters) Any collaborating objects, they need in order to function Correctly.
Declarative composition: Remove the dependent logic from the composition process.
Go doesn’t support any constructor mechanism.
Nil can only be used with pointer, error, slice, map, channel.
Concurrency

By leveraging concurrency, we can write high-performance software Systems.
Go is widely used for large scale distributed systems Where the concurrency capability give lot of advantage.
In concurrency Programming, we can execute independent functions, concurrently Independently of each other, that is at same time.
We execute Millions of tasks at the same time using concurrency.
Concurrency in Go is managed by a lightweight garbage collector and a concurrent environment/Concurrency runtime.
Green threads are threads That are scheduled by a runtime library or virtual machine(VM) Instead of natively by the underlying operating system.
In Go runtime There is a scheduler, which is responsible for creating and managing Go on time.
The scheduler software Is based on an algorithm called as m:n Scheduler algorithm

It is a Multiplexing algorithm
M stands for Number of Go routines.
N stands for Number of operating system threads.
As compared to Go routines The number of operating system threads will be very limited.

The number of operating system threads depends On the number of CPU cores.
A single OS thread can be used for executing many Go routines.
Go routine is a lightweight thread.
In earlier version of a Go, A single Go routine Could be of size 4KB, now they have reduced it to 2KB.

Go scheduler is a m:n Scheduler Which multiplexes(or schedules) m go routines On n OS threads.

Scheduler is responsible to schedule the Go routines On limited, number of OS threads.

In every Go programme at least one Go routine is there.

Main function is the actual Go routine.

In Go concurrency model, there are two primitives

Go routines

Go routine is a function that is running, concurrently.
Go routine can be launched by placing the Go Keyword before a function.
These are managed and created by Go runtime.
These are executed based on a technique called as m:n Scheduler

Maps m go routines to n OS threads.

Go routines are kind of green threads. Also known as co routines.
Go routine is a function running concurrently, independent of each other.
The concurrency executables Contain a garbage collector and a concurrency runtime.

Go runtime create a Go routine And assign against an operating system, thread that is bound to a CPU core.
The management is done by concurrency runtime.

Channels

Channel provide a simple mechanism for Go routine to communicate, and a powerful construct to build sophisticated concurrency patterns.
Channels provide a communication mechanism for Go routines to communicate with each other.

Go routines Share data with each other.

It follows a fork join model Once main is started As Go routine and then from it, child, Go routine, are created. Once work is done, it joins to main Go routine.
To start something as a Go routine, just add Go keyword before it.
We can write concurrent systems Without channels.
Non-concurrency programs Lead to blocking code.

These are also called as sequential programmes.

Sync package provides a WaitGroup Counting semaphore Which is typically used to wait for a group of semaphores or task to finish.

Weight group is mostly used in concurrency programming model.
Sync package provides synchronisation mechanism.
WaitGroup Add method, add the number of times, our semaphore can be used.

Each time we call it, it increment value to the wait-group counter.

WaitGroup Should either be a pointer or a package level variable. It should not be a copy.
WaitGroup Done method decrements, the counter by one.
WaitGroup wait method waits until The counter goes zero before proceeding with execution.

It acts as a blocker.

Wait Group Is used to synchronise the concurrently executing activity.
A wait group Is a counting semaphore Typically used to wait for a group of go routines or tasks To finish.
Wait method Blocks Until the wait group task counter, is zero.
Done function decrements , the weight group Task counter by one. It is equivalent to add -1.
Wait Group add method adds a numeric value To the wait group counter.
Wait group Must be passed as a reference because it acts as a semaphore or it should be a Package level variable.
When we write a Go function inside another Go function/inner function, we should define a separate wait group Mechanism for it.
New method creates a pointer. If we don’t use New while initialising each time a wait group variable, whenever the variable is passed. A copy is created.

Whenever we need to create reference use New.

A wait group must Not be copied after first use.
In programming, we use two kinds of memories

Stack frame

When we execute a function of stack frame is created.
Whenever we create a local variable of value type in that function, it is pushed into stack frame.
Once the function completes, the entire stack frame is removed automatically.

Heap memory

In a function, if we use a pointer or a reference type, it is stored in a heap memory.
In heap memory Manual allocation and deallocation is needed.
In reference type, there is no use of a copy.

Inner function Can use the same wait group variable without pointer. Only when function is outside, it should be passed as a pointer.
Wait, group done function should generally be a defer function

It should logically beon the top

In reference type, same memory is shared across the function.

Heap type Uses dedicated heap memory.

Channel is a data type used in concurrency programming

It can be created using any data type.
It is used to share data between autonomous tasks.
We may create a channel of empty struct Which may not be used to send data.
Empty struct Is mostly used in concurrency programming.
Channels provide a simple mechanism for go routines to communicate, and are a powerful construct to build sophisticated concurrency patterns.
Go routine is a concurrently executing function.

It is called by Go keyword followed by function name.
It is executed as an autonomous task that is a concurrently executing activity, independent of each other.
We need to take care of synchronisation of Go using wait group Mechanism.
Wait group is not a part of concurrency It is just a mechanism to control a Go routine function.

Most of the time concurrency is a composition of autonomous tasks.
We break a big task into small tasks and we execute them concurrently for achieving a common goal.
These tasks may need to share data between themselves.
Channel is a communication mechanism in go concurrency programming model.
Communication mechanism between go routines.
Channel is a conduit/pipe For communication between two Go routines.
Channel has two principal operations

Send
Receive

Send let us send data to channel data structure.
Receive helps us to receive a data sent on a channel.
There are two types of channel

Un buffered channel

No storage mechanism in the channel.
Also known For synchronous communication.
Blocks sending Go routine or receiving Go routine Until corresponding, send or receive happens on the same channel.
Blocks a send an operation Until a corresponding receive operation can be executed from different, Go routine.
If receiving operation is executed, First, it will block receiving Go routine Until sending go routine Can execute a send operation Since the un buffered channel Cannot hold any data.
Both send and receive will be executed at the same time And data will be received synchronously.
If receive operation execute First, it will be blocked as data is not available in the channel.
Un buffered channel blocks are sending Go routine or Receiving Go routine Until a corresponding send or receive is happening on same channel.

Such, a channel is also called as synchronous channel and communication is called as synchronous communication.

Buffered channel

Has a buffering capability that is temporarily storing the data.
There is a buffing capability whenever we have a send operation It is not blocked.
Data goes to temporary storage mechanism so that whenever a receive operation executes On same channel that data can be received without any blocking behaviour.
Stores Up to the capacity elements and provides FIFO Semantics.
A synchronous communication happens.
A buffer channel can be initialised using a capacity

If capacity is hundred we can make hundred send operations without any receive operation.
Send operation can be made without any blocking behaviour.

Hundred memory blocks are available Because we initialised as hundred capacity.
When we make a receive operation A memory is released because once data is consumed that memory block is freed.
It is a temporary storage mechanism until a receive operation is performed on the channel.
Once all blocks are full, and we try to make another send operation Then it works exactly like a un buffer channel that is it blocks the operation.
The 101. Send operation Without any corresponding, will get blocked until any receive operation can execute from a different routine.
Once a receive happens One memory block will be freed So that 101 send operation Can get a memory block In the buffered channel.
With un buffered channel Send First will be blocked until a corresponding receive operation could execute from the same channel and different go routine.
In buffered Channel with specific capacity, a send operation is executed Without any blocking operation as data is stored in a buffer.
Buffer channel is called as asynchronous, channel and communication is known as a synchronous communication.
It stores up to its capacity and provides First in First out semantic whenever we make a receive operation.
The first insertion/send operation will be the first receive operation That is based on First in First out semantic.
The message is sent through asynchronous medium.
Buffered acts like a message queue.

In concurrency Go routine We cannot predict the order sometimes send operation is executed first, sometimes they receive operation is executed first.
Slice, map, and channel or by default reference types, which should be initialised via literals{} or make.

Channel can only be initialised by make().
In order to create our own reference type, we can create a pointer or use a new built in function.

new(sync.WaitGroup)
&sync.aitGroup

We use chan and datatype to declare a channel

var ch chan string
We need datatype because channel is used to send and receive data.
Data type can be primitive,collection or user defined.
Once defined Send and Recieve will happen with that particular datatype

A channel declared but not initialized is called as an nil channel.
We initialize a channel using make(chan string))
If we initialize a channel with a second parameter of numeric value we specify it's capacity.

make(chan string,3)

This creates a buffered channel with capacity greater than zero.
Buffered channel is initialized with a predefined memory block.
We use a channel operator (<-) To perform Send /receive Operation on a channel.

v:=<-channel Is used to receive value from a channel thus performing receive operation.
Channel<-5 Is used to perform, send operation thus sending value to a channel.
When we make a send operation, the channel operator is on the right side.
When we make a receive operation Channel operator is on the left side.

When we make a send operation on unbuffered channel With No receiver, it block the executing Go routine.
Close function is used to close a channel from sending operation. But we can execute receive on the closed of channel.

If we try to make send operation on close channel We will get a runtime exception or a panic scenario.

We must close a channel once all sending is completed.
V:=<-channel Is used to receive data. If data is not available, we will get a default. Value of variable. It will also be a Blocking code.
V,exist : <-channel Is used to get data from Channel.

Exist checks for data on channel.
V Will get default value in case of no data.
exist==true

Data received from channel.

exist==false

Channel was closed, no more data left in the channel
Receive default value

Blocking code because send has not happened, No data available in the channel. Waiting for send operation.

Len function Can be used to find length of data in a buffered channel

Len Function Cannot be used on non-buffer channel.

Whenever we make a send operation on a async channel, the executing go routine Block till the time receive operation is performed on a channel.
Go channel mechanism doesn’t provide a broadcasting operation that is a value cannot be shared by many Go routines Only one Go routine Can receive the data.
Data is shared in a first in First out manner, the go routine Which executes receive First gets the data.
Multiple go routines Can Simultaneously recieve, the different data from the buffered.
Job can be distributed as more than one go routines can recieve data in sequence.
Closing of channel is not mandatory, but we should close it in real world to avoid Concurrency issues related to messages being Send when not required.

This is a risk in distributed environment.

For range Expression is used to continuously execute receive operation channel is closed.

It may receive irregular values.

When the send is stopped it is better to close the channel.
If send and receive, Happening continuously That is Background worker is sending messages continuously. In such rare scenarios, we may not Close channel.

Go routine Is An independent unit of work.
These, independent Units of work communicate through a channel.
If we Receive before Send, it will create a panic situation that is a runtime exception.
Channel acts as Signalling Mechanism Which signals for data Received from a go routine.
Pipeline concurrency pattern is used in concurrency where a big task is divided into small task. Output of one Go routine will be the input of second go routine , Output of second Go routine will be input of third Go routine and so on. This goes on till the number of sub Tasks/go routine We have are executed in order.

It works like a pipeline
For example, first Go routine finds 10 random numbers Then the second Go routine, find the Fibonacci values For the each value sent by First Go routine And then this fibonacci Is Printed using a third Go Routine.

A channel has basically three operations Send, receive, and close using these, we can achieve many technical solutions.

Channel is a reference type so when we pass it into a function, it will not be a value, but A reference That is will refer to same object.
After completing the Send operation We close the channel.
For range can be used to loop through the channel buffer to receive Values continuously.

We can also use for loop, but better is to use for range

The for range loop Will only exit when we close a channel else, it will wait for getting the data, and it will get a blocking behaviour. Eventually, we will get a deadlock and a runtime panic.
Receive operation can have three different behaviours

receive data from channel
Channel is closed, no more values we receive a default value
Channel will get blocked that is code will get blocked, data is not available and is waiting for getting a send operation.

Channel mechanism helps in orderly execution of Go routines, which by default, independent and concurrent in nature.

It helps us to control go routines

Generally The go routine which does not depend on receiving data from any channel is the one which Initialise execution.
If we put channel operator on the right side of the “chan” keyword It is a Send operation. When we give channel operator on the left side of the “chan” keyword It is a receive operation.

We call it channel direction

If we define this direction as a parameter in Go routine Then, in the routine, we are bound to that operation within the channel.

If we pass “in <- chan int” Then, in the Go routine, we can only receive integer from above channel.
If we pass “out chan <- int” Then in the Go Routine, we can only send Integer from the channel Specified
This makes code more readable and predictable.

Slice, map and channel will always be reference in Go, so when we pass as an argument We may not Make it as a pointer.
In Programming concurrency Is the composition of independently executing processes, While Parallelism is the Simultaneous execution of computations, which may be or may not be related to each other.

Concurrency is about dealing with lots of things once. Parallelism is about Doing lots of things at once.

There is no one to one mapping between a Go Routine and an operating system thread.

Single thread Can be used for executing several thousands of Go routine.
Go routine is not a thread But a single lightweight, thread.

We can limit our threads Using runtime library package. We can limit CPU cores etc
By default, a channel behaviour is by directional, unless until we specify directional operator.
Select case is a switch case like syntax in Go, but for channel operation.

If we are receiving data from two channels in a routine Then there is a dependency.Data received from channel 2 Maybe blocked till the time Data is not available in channel 1.
We can switch between channels based on data availability in channels
Select case evaluate the expression to receive data if data is available in a particular channel, it statements are executed.
Helps to eliminate Unnecessary blocking behaviour in case of multiple channels.
We can also perform a time out wait Using time, library after function

time.After(3* time.Second)

If More than one Case match, Go will randomly select A case And execute the Expressions.
If we have data for any channel, then that data should be received immediately and processed if Go routine is free.
A Variable Declared in case expression can be declared again in next case expression.
Case works for both Send and receive operations Of channels.

HTTP programming

Go is widely used for writing backend services, basically for HTTP and GRPC.
HTTP programming is a request response, programming model.
HTTP Client sends a request to the server.
Server serves the request And sends back a Response back to the HTTP client.
In Go, standard library package net/HTTP, provides the essential functionalities for writing HTTP applications.

Net/Http package provides A Foundational layer. It provides essentials for HTTP programming.
Major components of net/HTTP

ServeMux(struct): HTTP request Multiplexer(router)

ServeMux Is used to match the URL pattern and execute corresponding method/implementation.
ServeMux Is also called as HTTP request router.
ServeMux is used to configure all the URI Patterns. If there is a match in incoming URI And configured URI pattern, then Some implementation is executed.
We can create an instance of ServeMux And call its Methods to perform operations.

Handler(Interface): Serve the HTTP request. Writes, headers And bodies into HTTP response.

The implementation that ServeMux serves is called as A handler, which is an interface.
Using handler, we send back the response back to the client.
Handle interface has a method ServeHttp(ResponseWriter, *Request)
Both ResponseWriter and request come from Same HTTP Library.
Response writer is an interface type. Its implementation is already provided by HTTP library when we start this server. We just have to work with it. We do not need to provide its implementation.
Request is used to extract information from a HTTP client request. All the request parameters, all the request body, the form values we can extract from the HTTP request object.
Request is a struct type.
By using response, writer and request object, we can serve any request.
We should provide a concrete implementation of the handler interface.

HandlerFunc component.

HandlerFunc Component Is An adapter to allow the use of ordinary functions as HTTP handlers.
HandlerFunc is an implementation of handler interface.

type HandlerFunc func(ResponseWriter,*Request)
func (h HandlerFunc) ServeHTTP(w ResponseWriter,r* Request)

We do not need to provide a separate implementation for each URI If we use a HandlerFunc
The signature of HTTPFunc is same as ServeHTTP function.
HandlerFunc is a function type, We should pass a function type in it as a parameter.
http.NewServeMux Returns a pointer/reference to serve Mux type.

ServeMux is our RequestRouter
Lot of methods are there in ServeMux to configure our URI pattern.

Handler is an interface To serve our HTTP request. We create a type of HandlerFunc Which is an implementation of handler.
Once we configure all the methods and URI patterns using handler method of NewServeMux. We start our server.
ServeMux Handles function is used to configure URL and methods. It has two parameters URL and handle function which can be created through HandlerFunc.
Server is started using ListenAndServe Function of HTTP library, which takes ServeMux As parameter and address.

ServeMux Is also An implementation of handler interface.

We specify A verb before URL to specify Type of API example “POST /register”.

By default, request is GET.

For other features, we use a third-party library like to enhance HTTP router, et cetera.
There are also web application framework available to develop applications in Go.
It is not practical to create handler implementation For each of our handlers, so we use HandlerFunc.
By using ServeMux We can configure the URI pattern and a built in handler Implementation.

We use HandlerFunc for handler implementation.

ServeMux HandlerFunc function

Instead of using handle method Of ServeMux We can also use HandleFunc Which is also an implementation of Handle.
It takes two parameters

Pattern string
HandlerFunc(ResponseWriter,*Request)

Second parameter is a function and not An interface.

It allows us to directly plug-in a handler to a URI pattern.
So we need not provide a concrete implementation of handle interface.
Handle Func of ServeMux Internally calls the handle method.
The code is much simpler than handler Call.
Internally all code is dependent on handler interface.
Internally implementation of handler interface is called.
Also for ListenAndServe We create A server object, where we pass port and handler.
We use this server object to Call ListenAndServe.
ListenAndServe in HTTP only initialises two properties The port and router.
To Customise Our server, further, we directly create server object where we can customise more properties like error log, write time etc.
Using the server object we Call ListenAndServe.

In modern web applications, server is An REST api or GRPC API.

Client is a browser that is a Java script application that calls API.

Conventional web apps had server, which used to provide the server side code And UI code for web interface.

We had cookies to save session state.

By default, web application are stateless and not statefull

we can make them state full using DB persistence(key,value),cache, Cookies, et cetera, or any storage mechanism.
Session on stateless uses cookies to maintain data
We can use context object in the HTTP request object to store data.

Gin is the Most popular web application framework in Go.
Echo is another Web application framework in Go
Best is not to use any framework
In REST API We use a unique URI Along with a verb. Based on URI And verb, identify a resource Which will be provided from the server.

Verb can be GET,POST,PUT,DELETE

To develop a web Application in Go, we can Follow following Sequence

Start with the model and define the Constant and interfaces.
Add Memory store implementation.
Add a handler implementation And inject memory into that.
Create a server, Create a memory Instance, create handler instance And inject the Handler Instance, Create a ServeMux instance and integrate.

ServeMux is also an implementation of a handler interface.
When we work on HTTP Application

We use net/http + third party libraries

We use third party to extend some functionality for example replacing ServeMux with another router etc.
chi is a very popular router implementation library which is very feature rich.

It is compatible to go standard library package.

Another approcah is to use web framework

Gin is a very famous web framework
Second popular framework is echo

In echo there is a global error handelling mechanism that sends an error in http format back to client.
We can return error directly from hander in Echo framework

Frameworks provides helper methods example to decode an encode etc.
We can add additional properties to handler function in a framework using a middleware.

Example we have a panic recovery middleware,Logger middleware or Authorization Middleware.

Middlewares are automatically attached to a handler function.

Http middlewares are plugable functionality that can be decorated to all the handler functions.
Middleware functionality is executed with each route this can be either before or after.
Middlewares are Pluggable and self-contained piece of code that wraps web application handlers.
These are Components that work as another layer in the request handling cycle, which can execute some logic before or after executing your HTTP application handlers.
Great for implementing cross-cutting concerns: Authentication,authorization, caching, logging,panic recovery etc.
Web Application Frameworks provide lot of middlewares.
In Java filters and interceptors are used to implement middleware.
Cross cutting concerns are not part of a core application Logic, but are used across application.

Example authentication, authorisation, panic recovery Et cetera are called as cross Cutting concerns

A Middleware Accept an implementation of handler interface And returns an implementation of Router interface.

Since it returns, handler interface Value, we can use it for registering a route.

We can apply middleware to individual route specific level or we can apply to entire router instance.
If we are using framework, we need not write middleware's The framework itself Provides many necessary middleware.

mux was a very popular router library before servemux.
Gin and Echo framework provide a wrapper context over seperately handelling ResponseWriter and Request in Handler Functions.

The context contains Request and Response objects and also provides helpers for encoding Json and Decoding Json etc.

In Gin we pass context as a pointer where as in Echo we don't pass it as a pointer but as a value.
In Gin library if we create a router using Default() method then it automatically attaches Logger and Recovery middleware to each of the handlers by default.

Go Modules

There are a few challenges with package dependencies

Dependency management of third-party packages
Go get Always takes Latest version of packages.

Modules are how Go manages dependencies.
A single module is a collection of related Go packages that are version together as a single unit.
A module is defined by a tree of Go source files With a Go.MOD file in the tree’s root directory.
Modules record, precise dependency requirements and create reproducible builds.
Modules must be semantically Version in the form, V(major).(minor).(path) such as v0.1.0,v1.2.3 or v3.0.1(checkout http://semver.org)
Uses minimum version selection algorithm.
Go modules manage third-party dependences.
Workflow with Go modules

go mod init Will Automatically initialise a module with file go.mod.
Go get will, automatically Update the go.mod file.
Go get, will allow version selection to be overridden by adding an @version Suffix or “module query” To the package argument.

go get github.com/gorrila/mux@v1.6.2
go get github.com/gorilla/mux@‘<v1.6.2’

The environment variable configured using “go mod cache” Is the Path, where these third-party libraries are cloned once referred by Go get command.
By default, it takes the latest version.
In go.mod File, it makes an entry.

If the entry is followed by a comment, indirect, then it means that even though we have installed, we have not reference the library in our code.

Go mod Tidy Will synchronise the source code entry with the entry in Go mod File.

We should run this command before Committing code in version control and before compiling.
Go mod tidy ensures That the go.mod File matches the source code in the module. It adds any missing module requirements necessary to build the current module packages and dependencies, and it removes requirements on modules that don’t provide any relevant packages. It also adds any missing entries to go.sum And remove unnecessary entries.
If the library is not being used/referenced Go mod tidy Will remove it from go.sum file.

go mod edit - Provides a command-line interface for editing and formatting go.mod files, for use primarily by tools and scripts. (Eg: go mod edit -replace mycopmany.io/greetings=../greetings)
go mod download - Downloads the named modules into the module cache (GOMODCACHE)
go list -m - Print path of main module
go list -m -f={{.Dir}} - Print root directory of main module
go list -m all - View final versions that will be used in a build for all direct and indirect dependencies
go get -u ./... or go get -u=patch ./... (from module root directory) - Update all direct and indirect dependencies to latest minor or patch upgrades

Running Go get command with “-u” Flag update the version.
-u means Update to latest version.
This flag is mostly not used once we have included library in our code

go build ./... or go test ./... (from module root directory) - Build or test all packages in the module.
go.sum file is created to uniquely identify each library.
For every library, a hash is created in this file.
go.sum File is a part of go.mod File

This file should be committed along with source file And go.mod file.

If we don’t want to use a library Reference in our file, we can reference using “_” To avoid compiler error.

“_” Is called as blank identifier.

In order to work with databases, we use a standard library package called as “database/sql”.
For each library, we have two entries in the go.sum file.

Web framework in Go should be used in rare cases.
In Go function can be treated as a value, so we can directly pass a function in functions like HandlerFunc.
If we need to use error values Across the project, then we should create a package level error values.

If we need to create domainlevel error values We can put in same file as entities.

We should create a repository type For handling CRUD operations.

We can provide persistence for this interface, then in our DB memory store.

If we write a function name, it will not be invoked But if we write a function name with brackets “()” It will invoke the function.

In the later case It will pass function as a value That is when we write only function name.

Unit Testing

test driven development

Write unit test before writing production code.
Test driven development is also called as Red-Green-Refractor.
First, we define the test, and then we define its implementation until the test passes. This stage is called as green.
Code should be highly testable And clean
Once the test is green That is it passes we refactor the code.

Define behaviour before writing code

example user should be able to create customer
Customer ID should be unique.

Testing in Go

“testing” Is the foundation library for unit testing.
“net/http/httptest” Helps in writing test for HTTP application.

ResponseWrite and Server object.

Naming convention for writing unit test

Test Suit file: Go source file In which you write unit tests Where the name should end with _test.go
Test function func TestXYZ(t *testing T)

“Go build” and “Go install” exclude all files whose name end with _test.go
“Go test” compiles The entire Package source and runs unit test cases from the test, suit file.
We write test suit file In the same Package Directory, where we write project code.

We can have a different Directory though in some cases/ Specific scenario, but preferred approach is same package Directory.

Test function name should start with a “Test” Followed by alphanumeric name.

The function should accept a parameter(t *testing T)

Testing library doesn’t provide an assertion mechanism. So we assert using a third-party library.

github.com/stretchr/testify/assert

To execute test, we use “go test -v”

-v stands For verbose Which shows details
To get test coverage use “- cover”.

Unit testing can be at functional level or user story level.
Table testing

Run uni tests using “go test ./…”
We write test cases for a bunch of behavioural aspects and not a single behaviour.
We Create a table(Collection) Of test cases or user stories.
We create a slice of a struct Which has following properties

Name of test case
Entity for which test case is defined
Expected value of error/response

Go provides a mechanism for sublevel testing, where we can Iterate through the above, slice and test

To run the sublevel test, we use function t.run(name,test function())
In the test function, we use the Expected value.

We should always try to segregate different concern in different modules. For example, HTTP controller should not handle persistence. It should be handled by separate services.

we achieve this by injecting Repository in a controller.
When we define code based on their behaviour/concern in separate module injected in each other, each module can be mocked Need basis. This makes code more testable.
For example, during testing repository can be mocked When injected into the controller So, actual data is not impacted.
In unit test, we look for individual components, isolated from dependencies

For handler, we should only focus on request and response, isolated from dependencies Such as repository or service.

net/http/httptest

ResponseRecorder

ResponseRecorder Is an implementation of http.ResponseWriter Interface that records its mutations for later inspection in tests.

Server : Test http server For use in end to endHTTP Test.
When we call handler function, we need request and response object.
To test handler, we use response recorder from above library
ResponseRecorder is an implementation of response writer interface.
For all handler Where will pass ResponseWriter We pass ResponseRecorder.
ResponseRecorder Can be created Using httptest.NewRecorder().
To mock objects, we use gomock library

gomock library is maintained by uber.
Mocking services in controller

BDD with ginkgo

create one suit for a single package and one for multiple spec file.

Bootstrapping is a suit : ginkgo bootstrap

Adding specs to a suit

Adding specs to a suit : ginkgo generate

Nil can only be used for Reference types like map, channel, error, slice

Nil is used as a pointer

Generics

Generics are a way of writing code that is independent of the specific types being used.
With generic, you can declare and use functions or types that are written to work with any of a set of types Provided by calling code.
Functions and types are now permitted to have type parameters. A type parameter list looks like an ordinary Parameter list, except that it uses Square Brackets instead of parenthesis.
func SumNumbers[K comparable, V number](m map[K]V) V{ }
Generics were Recently added to Go.
For example, if we want to use same logic on the floating type and integer type Array/collection We can write a common generic type.

If we do not have generic types, we will have to write separate functions.

We use “ Comparable” Type to Support all types in Go.

This is helpful in Maps “key” values.

We can also create an interface to support selective types

This is called as a constraint contract.

We define generics In square brackets after function name

We can provide selected type for a generic Parameter or use a comparable

We can also use alias types In generics.
We can add user defined types as well.
We can also create a struct with generic.
Keyword “any” Is represented as an Empty interface, which means any value can be passed.

Generics are basically Used for collection data structures.

Comparable vs any

Both are predeclared constraints used with generics, but they serve different purposes.
Any

Alias for interface{} — accepts every type
Use when you just need to hold or pass a value of unknown type
You cannot use == or != on values constrained by any

Comparable

Accepts types that support == and != operators
Includes: int, float64, string, bool, pointer, struct (with comparable fields), array, channel
Excludes: slice, map, func (these can’t be compared with ==)
Comparable is an interface that is implemented by all comparable types.

Slices and maps are utility libraries That provide operations on slice and map, respectively.
Logging/Log

Package “log/slog”
Package slog Provides “ Structured logging” In which log records include a Message, a severity level, and various other attributes expressed as key value pairs.
It defines a Type,Logger, Which provides several methods such as (loggerInfo and loggerError) for reporting events of interest
Each logger Is associated with a handler. A logger output method creates a record from the method arguments and passes it to the handler, which decides how to handle it. There is a default logger accessible through top level functions(Such as Info and Error) That Call the corresponding Logger methods.
A Log record Consist of a time, a level, a message and a set of key value pairs where keys are string and values may be of any type.
Example slog.info(“hello”,”count”)
Log level

Type level Int
A level is the importance or severity Of a log event. The higher the level, the more important or severe the event.

Const(LevelDebug Level=4,LevelInfo Level=0,LevelWarn Level=4,LevelError Level =8)

Initially, logging was done through third-party libraries.
In Recent lator versions Go has included a library called as “log/slog” Which can be used for enterprise applications.
Third-party libraries may have a lot of internal third-party dependencies with other third-party libraries. So they may create Dependency Compatibility issues.
Structured, logging records, logs, tracing and implementation

We achieve Observability pattern using this.

Structured logging includes a lot of information in key value pairs.

This information is then used by log analysis tools like Kibana

slog was Included in Golang version 1.22.
Slog functions provide First parameter as message, which is a string, and then variadic parameters Of key value pairs.
We should often use The function LogAttrs of slog library.

LogAttrs Has following parameters.

Context, which can be empty or Nil value

Context is mostly passed as Nil using context.Background().

Level, we provide as information level/log level
Log message as string
Variadic parameters of Struct “Attr” type(accepts key value Pair)

example slog.String(“created by”,user)
Slog.Int(“orderId”,O.id)

For production systems, we should use slog.LogAttrs() method.

We can use New() Function of slog To add our writer implementation to logger.

slog.New(slog.NewTextHandler())
slog.New(slog.NewJsonHandler())

With Jason handler, data is captured in Jason format.

Logging is treated as a high-level module Thus, we should inject it as a Dependency like persistence in module.

Package Context

Package context defines the Context type, which carries deadlines, cancelation signals, and other request-scoped values across API boundaries and between processes.
Context type Is used to create a context object.
Context value is created by using context package methods
Context.context can also be used to hold key value pairs of data.
Contact is heavily used in concurrency programming.
While creating context with any function, we Add a Parent context. Initially, the parent context is null So we pass context.Background.
Context created using:

WithCancel

We have to manually Call the cancel function.
WithCancel Returns a context And a cancel function. The cancel function is used to send a cancellation signal wherever We pass this context.

WithCancelClause

we can pass error value Else same as with cancel.

WithDeadline

Is called internally by With time out.
We have to define the deadline/time
Automatically calls the cancel()
It starts the timer after the first time cancel method is called
Cancel is Generally used with defer function

WithDeadlineClause

We can pass error value else As same as With deadline.

WithTimeout

We Define a timeout, That time out Defines the deadline/time, thus Internally calling WithDeadLine.
Use defer cancel() to evaluate function, which starts the timer.

WithTimeoutClause

we can pass error value else same as WithTimeout.
(context,duration,error)

WithValue

Do not pass a nil Context, even if a function permits it. Pass context.TODO if you are unsure about which Context to use.
Use context Values only for request-scoped data that transits processes and APIs, not for passing optional parameters to functions.
The same Context may be passed to functions running in different goroutines; Contexts are safe for simultaneous use by multiple goroutines.
func DoSomething(ctx context.Context, arg Arg) error {}
We can check channels for signals from Go routine, and if work is done, we may need to stop go routine.
A context can pass signals with following data.

Cancellation

We may need to send a cancel signal to a leaking Go routine/Unnecessarily running Go routine.
Context.done() Method Returns an empty struct Once Context is cancelled.

Empty struct Doesn’t take any memory and is used for signaling closure in concurrency programming.
We can also send error Value with cancel, which is received in context.Err()

If we use “with the cause” then cause() Method will Return a Non nil value.
Cancellation signal is send in withCancel and withTimeout

Withtimeout internally calls withdeadline.
In withDeadline We need to provide exact date and time which is unrealistic in many cases, so basically we use withTimeout.

Context.Done() should always be used with a select case.

Key Value Pair of data

Used Highly with GRPC API.
We use WithValue function.
In GRPC Programming Server Side Methods Have a Context And request object and it returns response object.

Context object contains key value pairs like authorisation token, et cetera.
This key value pair is defined With value.

This value can be extracted From our server implementation.

We can use these context in combination as well. We have to define a parent child relationship But in this case, we should create a parent child relationship in context.
In withCancel, withDeadline, withTimeout We cannot create a key value pair.
Context is used to share data between middleware And route specific handler functions.

Middlewares are used for wrapping route specific handler function with the some extra pluggable information.
Always middleware logic is executed first

Working with SQL Databases

For working with SQL databases, there is a unified approach, but for other noSQL Database, we should use a vendor specific package as there is no unified approach
In Go standard library package, there is a package called as "database/sql" provides a generic interface for SQL (or SQL-like) databases.
The database/SQL package needs some vendor specific implementation.

In vendor specific package We have init function Which initialise’s SQL package.
We can easily move from one database to another database by changing the implementation.

The sql package must be used in conjunction with a database driver:

https://go.dev/wiki/SQLDrivers

We should never use API of vendor specific package. If we import vendors specific package along with database/sql package.
Approaches

Write SQL statements in Go code with database/sql package
Use an ORM

GORM: https://gorm.io/

Go ORM Is a vert lightweight And most commonly used library.

Ent: https://entgo.io/ (by Facebook Open Source)

ENT is used next to Go ORM And is developed by Facebook. This project is currently maintained by Linux foundation.
Instagram has also contributed to this project
It has a very vast ecosystem.
Once we use domain model of this ORM We can generate code for REST API , GRPC API.
This ORM Is not light weight.

Compile SQL to type-safe Go code(https://sqlc.dev)

This approach is called as SQLC.
This approach is now being used by other developer communities too.
This approach was started by open source, Go community.
In SQLC we create a configuration file, which has information regarding our database.
We also provide SQL files for queries and schema.
We use “sqlc generate” to generate code corresponding to schema file.
Initially, SQLC was designed for python only, but due to its popularity, it’s expanding for other languages as well like Go.

To perform a create operation, we use db.exec() Function.

It returns a result and error

Query Function returns, multiple rows
QueryRow Returns a single row.
DB also has an integration with context and using execContext(context,query) function We can pass context.

Context should always be the first parameter when passed in any library.

We should try to use context compatibility, API wherever possible.

References

Search This Blog

GoLang Implant

Introduction

Comments

Post a Comment