Golang: A Systems Programming Open Source Language by Google


Go is an attempt to combine the ease of programming of an interpreted, dynamically typed language with the efficiency and safety of a statically typed, compiled language. Go, often referred to as Golang, is an open source programming language created at Google in 2009 by Robert Griesemer, Rob Pike, and Ken Thompson.

Google describes its plans for Go in one of its blog posts as, “We’re hoping Go turns out to be a great language for systems programming with support for multi-processing and a fresh and lightweight take on object-oriented design, with some cool features like true closures and reflection. Go attempts to combine the development speed of working in a dynamic language like Python with the performance and safety of a compiled language like C or C++.”

This astounding language is meant to be simple-to-learn, concise and easy-to-read by other developers. It offers an expressive type system, as well as fast compilation, good performance and built-in language features that simplify concurrency. Go is reminiscent of C in its syntax, making it relatively easy for long-time C developers to learn. It uses interfaces as the building blocks of code reusability. Golang is a compiled language that supports static linking, and Go code can be statically linked to a native binary and be deployed in cloud servers easily, without worrying about dependencies.

Go, which provides a rich standard library, is designed primarily for systems programming. Its credentials are unsurpassed. Go provides type safety, garbage collection, dynamic-typing capability, many advanced built-in types such as variable length arrays and key-value maps, etc.


Why Go?

Go is recommended for the following features:

  • It is simple, concurrent and has good cross-platform support.
  • Go is awesome for microservices. Microservices designed with Golang are easy to modify, debug and test. You can change one service without impacting the entire functionality, and can quickly change the design and add new functions.
  • Golang can be used for server development. It is a general-purpose language that is suitable for many things including server side Web applications, distributed apps, DevOps, etc. Currently, Docker is probably the most successful, well-known container platform. Google is also building Kubernetes, a Docker competitor using Go. Many big companies including Google, Dropbox, Soundcloud, Cloudflare, etc, use it for their projects.
  • The use of Go for enterprise development has become a trend. For example, Netflix uses Go for exactly this purpose. Another reason is its efficient data processing on servers and optimised server loading. Golang enables non-disruptive background loading.

Go does have a few drawbacks, though, which are mainly in graphical and machine learning. It has become more prominent after many blockchain platforms started using it for development.


Golang is supported on all the three platforms — Mac, Windows and Linux. You can download the binary for the corresponding platform from https://golang.org/dl/.

In Linux, download the tar file from https://golang.org/dl/ and unzip it to /usr/local to create a Go tree in /usr/local/go. For example:

tar -C /usr/local -xzf go1.4.linux-amd64.tar.gz

Add /usr/local/go/bin to the PATH environment variable, as shown below:

export PATH = $PATH:/usr/local/go/bin

For installing Go in Ubuntu, run the following command:

sudo apt-get install golang

After the Go installation is done, you can check the version by using the following command:

go version

Programming with Go

Some of Google’s sample Go code reveals that the syntax is C-like. It incorporates functions, decision making and loop control statements, standard conditional expressions and many other features that you’d expect to find in a C-like language, but with a handful of nice twists. There are some Python-like features too, including array slices and a map type with constructor syntax that looks like Python’s dictionary concept but eschews some typical object-oriented programming concepts such as inheritance.

A Go program can vary in length from three lines to millions of lines, and it should be written into one or more text files with the extension .go. For example, hello.go.

Vi, vim or any other text editor too can be used to write a Go program into a file. Ensure the Go compiler is in the path and that it is being run in the directory containing the source file hello.go.

Our first Go program: first.go

To begin, give the following commands:

package main

import “fmt”

func main()


fmt.Println(“Hello World!”)


Compile it and run it using the go run command:

go run first.go

Here is the output:

Hello World!

Here is a brief explanation of what each line does in the program.

package main: This is the first line of the program and defines the name of the package in which this program lies. It is a mandatory statement, as Go programs run in packages that provide code reusability.

import fmt: This is a preprocessor command, which tells the Go compiler to include the files in the package fmt.

func main(): This is the main function where the program execution begins.

fmt.Println(): The fmt package has exported the Println method, which is used to write text to the standard output. P is written in upper case. In the Go language, if a name that starts with a capital letter is exported, it implies that the function or variable/constant is accessible to the importer of the respective package.

Tokens in Go

Tokens are the building blocks of any programming language and consist of keywords, identifiers, variables and constants. There are 25 keywords in Golang and some of the reserved words are: break, chan, defer, fallthrough, go, map, package, var, type, interface, etc. An identifier in Go starts with any letter from A to Z or a to z or an underscore (_) followed by zero or more letters, underscores, and digits 0 to 9.

Data types in Go

The following are the basic data types available in Go:

1. Boolean types that consist of the two predefined constants — (a) true, and (b) false.

2. Numeric types that are again arithmetic types and represent integer types or floating point values throughout the program. The predefined architecture-independent integer types are: int, int8, int16, int32, int64 (signed integers) and uint, uint8, uint16, uint32, uint64 (unsigned integers), float32 and float64.

  • int: This represents 32- or 64-bit integers, depending on the underlying platform. Size and other details are the same as that of C language.
  • Other numeric types include byte and rune. The former is an alias of uint8 and rune is an alias of int32.

3. String types represent the set of string values. Its value is a sequence of bytes. Strings are immutable types, the contents of which cannot be changed once created. The pre-declared string type is string.

4. Derived types, which include pointer types, array types, structure types, union types, function types, slice types, interface types, map types and channel types.

Variable declaration in Go

The var name type is the syntax to declare a single variable. For example: var a int, var b bool, var st string.

package main

import “fmt”

func main()


var age int // variable declaration

fmt.Println(“my age is”, age)


Since the variable, age, is not assigned any value, Go automatically initialises it with the zero value of the variable’s type. We can declare multiple variables at once, as follows:

var salary, amount int

Go enables us to declare multiple or single variables and initialise them at the same time:

var age, salary = 25, 30000

package main

import “fmt”

func main()


var number, amount = 10, 15

var sum = 20

fmt.Println(number, amount, sum) prints the o/p, 10 15 20


Go has awesome shorthand for declaring and initialising a variable. The syntax is:

variable := value

number := 10

amount := 15

fmt.Println(number, amount)

Printf can also be used along with the corresponding control strings in Go:

package main

import “fmt”

func main() {

var i int

var f float64

var b bool

var s string

var name = “Ann”

fmt.Printf(“%T %T %T %T\n”,i,f,b,s) // Prints type of the variable

fmt.Printf(“%v %v %v %q \n”, i, f, b, s) //prints initial value of the variable

fmt.Printf(“type : %T & value : %v\n”, name, name)


The output will be:

int float64 bool string

0 0 false “ ”

type: string & value : Ann

Decision making statements

1. If statement: An if statement consists of a Boolean expression followed by one or more statements:

package main

import “fmt”

func main()


number := 10

if number >= 5


fmt.Println(“I will print the value:”, number)



Unlike in other languages like C, the curly braces are mandatory even if there is only one statement between the { }.

2. If..else statement

package main

import “fmt”

func main()


num := 10

if (num > 0)

{ //checks if number is positive

fmt.Println(“the number is positive”)




fmt.Println(“the number is negative”)



Nested if..else : (Complete using greatest of 3)

package main

import “fmt”

func main()


x:= 10 y:=20

if( x >=10 ) {

if( y >= 10 )


fmt.Printf(“Inside nested If Statement \n” );



fmt.Printf(“Value of x is : %d\n”, x );

fmt.Printf(“Value of y is : %d\n”, y );


Switch in Go

Switch statements are used to check conditionals with many cases. We can also check multiple expressions by separating them using commas:

number := 10

switch number


case 5:

fmt.Println(“The number is 5”)

case 10,20,30:

fmt.Println(“The number is a multiple of 10”)

case 7,13:

fmt.Println(“The number is prime!”)




The for loop is:

func main()


for i := 1; i <= 5; i++


fmt.Println(“Value:”, i)



Multiple initialisation and increment in a for loop is as follows:

package main

import “fmt”

func main()


for no, i := 10, 1; i <= 10 && no <= 19; i, no = i+1, no+1

{ //multiple initialisation and increment

fmt.Printf(“%d * %d = %d\n”, no, i, no*i)



The syntax for creating an infinite loop is shown below:




Functions in Go

The syntax of function definition in the Go programming language is as follows:

func function_name( [parameter list] ) [return_types]


body of the function


The function declaration starts with the func keyword followed by the function’s name. The parameters are specified between (‘and’) followed by the returntype of the function. The syntax for specifying a parameter is the parameter’s name followed by the type. Any number of parameters can be specified like parameter1 type, parameter2 type. Then the body of the function block, or collection of statements that define what the function does, is enclosed in { }.

func sumTotal(price, no int) int //if the consecutive parameters are of the same

{ type, we can skip writing the type each time

var total = price * no

return total


package main

import “fmt”

func calculateBill(price, num int) int


var totalPrice = price * num

return totalPrice


func main()


price, num := 90, 6

totalPrice := calculateBill(price, num)

fmt.Println(“Total price is”, totalPrice)


Function to swap 2 numbers:

func swap(x, y int) (int, int) {

return y, x


func main() {

a, b := swap(10, 20)

fmt.Println(a, b)


Arrays, slices and maps in Go

Instead of declaring individual variables, such as number0, number1… and number99, you declare one array variable such as ‘numbers’ and use numbers[0], numbers[1], and numbers[99] to represent individual variables. In Go, an array is a numbered sequence of elements of a specific length.

var variable_name [SIZE] variable_type

Eg: var x [10] int //This is the example of array declaration in go

func main() {

var a [2]string

a[0] = “Hello”

a[1] = “World”

fmt.Println(a[0], a[1]) //prints the o/p : Hello World

fmt.Println(a) //prints the o/p : [Hello World]

primes := [10]int{2, 3, 5, 7, 11, 13}

// short hand declaration to create array

fmt.Println(primes) // prints the o/p : [2 3 5 7 11 13 0 0 0 0], remaining elements filled with 0

The Go programming language allows multi-dimensional arrays. The following example prints a 2D array:

func main() {

var twod [2][3]int

for i := 0; i < 2; i++ {

for j := 0; j < 3; j++ {

twod[i][j] = i + j



fmt.Println(“Elements : “, twod)



A slice is a convenient, flexible and powerful wrapper on top of an array. Slices do not own any data on their own. They are just the references to existing arrays.

The type [ ]T is a slice with elements of type T. A slice is formed by specifying two indices, a low and high bound, separated by a colon:

func main() {

names := [4]string{“John”,”Paul”,”Ann”,”Manu”,}


a := names[0:2]

b := names[1:3]

fmt.Println(a, b)


[John Paul Ann Manu]

[John Paul] [Paul Ann]


Go provides another important data type named the map, which maps unique keys to values. The declaration is as follows:

/* declare a variable, by default map will be nil*/

Syntax : var map_variable map[key_data_type]value_data_type

Eg: var namedepartment map[string]string

You must use make function to create a map.

Syntax : map_variable = make(map[key_data_type]value_data_type)

Eg : namedepartment= make(map[string]string)

package main

import “fmt”

func main() {

personSalary := make(map[string]int)

personSalary[“Liz”] = 12000

personSalary[“Amy”] = 15000

personSalary[“Mike”] = 9000

fmt.Println(“personSalary map contents:”, personSalary)


Prints the o/p:

personSalary map contents: map[Liz:12000 Amy:15000 Mike:9000]

Pointers in Go

Go supports pointers, allowing you to pass references to values and records within your program.

The syntax for pointer declaration is as follows:

var pointer_name *pointer_data_type

Eg: var b *int

func main() {

b := 255

a := &b

fmt.Println(“address of b is”, a)

fmt.Println(“value of b is”, *a)


fmt.Println(“new value of b is”, b)


It prints the following output:

  • The address of b is 0x10414020.
  • The value of b is 255.
  • The new value of b is 256.

Structure in Go

To define a structure, you must use the type and struct statements. The struct statement defines a new data type, with multiple members for your program. The type statement binds a name with the type which is ‘struct’ in our case. The format of the struct statement is as follows:

type struct_variable_type struct {

member definition;

member definition;


member definition;


Once a structure type is defined, it can be used to declare variables of that type using the following syntax:

variable_name := structure_variable_type {value1, value2...valuen}

type Books struct {

title string

author string

subject string

book_id int


func main() {

var Book1 Books /* Declare Book1 of type Book */

var Book2 Books /* Declare Book2 of type Book */

/* book 1 specification */

Book1.title = “Wings of Fire”

Book1.author = “ A.P. J. Abdul Kalam”

Book1.subject = “An Autobiography”

Book1.book_id = 63108786

/* book 2 specification */

Book2.title = “Academic English”

Book2.author = “Pearson”

Book2.subject = “Check your English Proficiency”

Book2.book_id = 6495700

/* print Book1 info */

fmt.Printf( “Book 1 title : %s\n”, Book1.title)

fmt.Printf( “Book 1 author : %s\n”, Book1.author)

fmt.Printf( “Book 1 subject : %s\n”, Book1.subject)

fmt.Printf( “Book 1 book_id : %d\n”, Book1.book_id)



Book 1 title : Wings of Fire

Book 1 author : A.P. J. Abdul Kalam

Book 1 subject : An Autobiography

Book 1 book_id : 63108786


Go programming provides another data type called interfaces, which are a set of method signatures. Interface specifies what methods a type should have, and the type decides how to implement these methods.

import “fmt”

/* define an interface */

type SalaryCalculator interface {

CalculateSalary() int


/* define a permanent employee */

type Permanent struct {

empId,basicpay,pf int


/* define a contract employee */

type Contract struct {

empId,basicpay int


//salary of permanent employee is sum of basic pay and pf

func (p Permanent) CalculateSalary() int {

return p.basicpay + p.pf


//salary of contract employee is the basic pay alone

func (c Contract) CalculateSalary() int {

return c.basicpay


/* define a method for SalaryCalculator */

func getSal( salarycalculator SalaryCalculator) int {

return salarycalculator.CalculateSalary()


func main() {

perm := Permanent{empId:10,basicpay:40000,pf:8000}

cont := Contract {empId:20, basicpay:25000}

fmt.Printf(“Permanent salary: %d\n”,getSal(perm))

fmt.Printf(“Contract salary: %d\n”,getSal(cont))


The Output will be:

  • Permanent salary: 48000
  • Contract salary: 25000

To reiterate, Go, which is sufficiently mature and stable has its own elegance and programming idioms that make the language productive and fun to code. Go also provides a comprehensive standard library with the core packages that programmers need to build real world and Web based programs. Though originally designed for systems programming, Go has become increasingly popular with Web application development, and can be found in many open source and commercial software applications. To sum up, Golang, with its concurrency, channels, interfaces, inheritance, unit testing and packages, is easier to learn for freshers, compared to experienced developers, because they can quickly understand and adapt.



Please enter your comment!
Please enter your name here