Category: Uncategorized

Goroutines: Threading made easy!

Post author By masnun
Post date August 2, 2013
2 Comments on Goroutines: Threading made easy!

This post is dedicated to the awesome concept of “Goroutines” in Go. A “Goroutine” (Go Routine?) is a lightweight thread implementation that executes asynchronously with the main process. To define a goroutine, we use the “go” keyword before a function call. Instead of a regular blocking call, the function is then executed asynchronously.

Let’s jump into a quick demonstration. We shall write a program that creates multiple threads, each thread sleeping for a random period of time. For us, the mere mortals, we shall politely ask the threads to print some information so that we can tell when they go to sleep and when they wake up!

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {

	// let's create 5 goroutines using for loop
	for i := 0; i < 5; i++ {

		// the go keyword makes it a goroutine, making the function
		// execute asynchronously instead of a blocking call

		// we are using anonymous function for simple
		// demonstration

		go func(num int) {
			// let's seed the random number generator
			rand.Seed(time.Now().UnixNano())
			// create a random number for sleeping
			sleepDuration := rand.Intn(20)
			// let's print a message before sleeping
			fmt.Printf("[%d]: Sleeping for %d milisecs \n", num, sleepDuration)
			// ZzzzZzzZZZzzzz!!
			time.Sleep(time.Duration(sleepDuration) * time.Millisecond)
			// Good morning, World!
			fmt.Printf("[%d]: Woke up! \n", num)
		}(i)
	}


    // delay the main process so that others can print to the terminal
	var input string
	fmt.Scanln(&input)

}

package main

import (

"fmt"

"math/rand"

"time"

)

func main() {

// let's create 5 goroutines using for loop

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

// the go keyword makes it a goroutine, making the function

// execute asynchronously instead of a blocking call

// we are using anonymous function for simple

// demonstration

go func(num int) {

// let's seed the random number generator

rand.Seed(time.Now().UnixNano())

// create a random number for sleeping

sleepDuration := rand.Intn(20)

// let's print a message before sleeping

fmt.Printf("[%d]: Sleeping for %d milisecs \n", num, sleepDuration)

// ZzzzZzzZZZzzzz!!

time.Sleep(time.Duration(sleepDuration) * time.Millisecond)

// Good morning, World!

fmt.Printf("[%d]: Woke up! \n", num)

}(i)

}

// delay the main process so that others can print to the terminal

var input string

fmt.Scanln(&input)

}

The blocking call (from the main process) always executes first. The Scanln() call waits for user input thus allowing the async functions to print their information on the terminal. If we don’t wait, the main process will finish execution and the program will quit. Since the other functions are async, we shall never see their outputs. So we wait and wait for their messages! 🙂

Sample output?

Lighthouse: ~/Codes/go
$ go run main.go
[0]: Sleeping for 3 milisecs
[1]: Sleeping for 18 milisecs
[2]: Sleeping for 2 milisecs
[3]: Sleeping for 16 milisecs
[4]: Sleeping for 9 milisecs
[2]: Woke up!
[0]: Woke up!
[4]: Woke up!
[3]: Woke up!
[1]: Woke up!

Lighthouse: ~/Codes/go

$ go run main.go

[0]: Sleeping for 3 milisecs

[1]: Sleeping for 18 milisecs

[2]: Sleeping for 2 milisecs

[3]: Sleeping for 16 milisecs

[4]: Sleeping for 9 milisecs

[2]: Woke up!

[0]: Woke up!

[4]: Woke up!

[3]: Woke up!

[1]: Woke up!

It’s simple, right? In some languages, you have to subclass a built in class and then define specific methods to direct the behavior/actions. In Go, you just define a function and prepend “go” before making the function call. Good thing, you can use anonymous functions and invoke them immediately as well.

For communication between these goroutines, we can use “Channels”. Hope to write another blog post on using channels soon.

Uncategorized

The “Go” Programming Language: A First Look [Part-1]

Post author By masnun
Post date July 29, 2013

It’s been a while I am looking at Go. The language is nice, feels like a mixture of Python and C with huge performance gains and some innovative language features. In this post, I would try to quickly focus on the basics of “Go”. I hope I shall write more on the language in the coming days.

Installation

Installation is really platform specific. I would happily forward you to http://golang.org/doc/install for installation instructions on your OS.

If you happen to have the same OS as mine, that is OSX, I highly recommend installing Go using Homebrew. It’s just a matter of one line –

brew install go

1	brew install go

Once it’s installed, you can display useful information with this command –

brew info go

1	brew info go

If you are on Windows, Linux or any other OS, please follow a suitable instruction set from the documentation.

Running Go Programs

How does a first program look on Go? Let’s see –

package main
func main() {
	print("Hello World! \n")
}

package main

func main() {

print("Hello World! \n")

}

A Go file must define a function named main if you want to run it. We can define a function in go using “func” keyword.

Running it –

go run main.go

1	go run main.go

You can directly run a Go file by using the “go run” command. This comes in handy for debugging, if you want to build a compiled binary, use “go build”.

Lighthouse: ~/Codes/go
$ go build main.go

Lighthouse: ~/Codes/go
$ ls
main    main.go

Lighthouse: ~/Codes/go
$ ./main
Hello World!

Lighthouse: ~/Codes/go

$ go build main.go

Lighthouse: ~/Codes/go

$ ls

main main.go

Lighthouse: ~/Codes/go

$ ./main

Hello World!

Variables, Constants and Printing

First, how do we define variables in Go? It’s simple –

var variableName variableType = "default value"

1	var variableName variableType = "default value"

In Go, we can import packages using the “import” keyword. The package “fmt” has a nice function named “Println” which is more or less Go equivalent to System.out.println() in Java. Let’s see a code sample –

package main

import "fmt"

func main() {
    //var variableName variableType = "default value" 

    var name string = "masnun"
    var age int = 23

    fmt.Println(name);
    fmt.Println(age);
}

package main

import "fmt"

func main() {

//var variableName variableType = "default value"

var name string = "masnun"

var age int = 23

fmt.Println(name);

fmt.Println(age);

}

If you are initializing a variable, you can optionally skip the variable data type. Go can infer that from the initialization.

There is a shorthand format for declaring and initializing a value quickly –

name := "masnun"

1	name := "masnun"

It will create a var type string and assign the value “masnun” at the same time.

To create a constant, we just replace “var” with “const”. Example:

const s string = "constant"

1	const s string = "constant"

Looping

In Go, we use “for” for all types of looping. Check out –

While Loop:

package main

import "fmt"

func main() {
	i := 1
    for i <= 10 {
        fmt.Println(i)
        i = i + 1
    }
}

package main

import "fmt"

func main() {

i := 1

for i <= 10 {

fmt.Println(i)

i = i + 1

}

Generic For Loop:

package main

import "fmt"

func main() {
	for i := 1; i <= 10; i++ {
        fmt.Println(i)
    }
}

package main

import "fmt"

func main() {

for i := 1; i <= 10; i++ {

fmt.Println(i)

}

We can do common “foreach” loops combining “for” with “range”. We shall see them in the next section.

Arrays, Slices and Maps

Arrays:

If you are any programmer at all, I probably don’t need to tell you about arrays. Defining arrays in Go is easy.

The syntax is –

var arrayName [size]type

// Example: an array of 5 integers

var numbers [5]int

var arrayName [size]type

// Example: an array of 5 integers

var numbers [5]int

We can reference the indexes just like in any other language. We can even declare and initialize an array on the same line. Take a look at the example:

package main

import "fmt"

func main() {

	var numbers [5]int
	numbers[1] = 2
	fmt.Println(numbers)

	var initNumbers = [5]int{1, 2, 3, 4, 5}
	fmt.Println(initNumbers)

}

package main

import "fmt"

func main() {

var numbers [5]int

numbers[1] = 2

fmt.Println(numbers)

var initNumbers = [5]int{1, 2, 3, 4, 5}

fmt.Println(initNumbers)

}

Slices:

Slices are like arrays but not fixed size. However, the type must remain the same. I mean you can’t add a string type to an integer slice.

We use the make() function to create a slice. In fact, in Go, make() can create a lot of stuff for me. We shall soon find out. For now, let’s see how we can use a Slice.

package main

import "fmt"

func main() {

	strSlice := make([]string, 1) // we make a slice & initialize with one item

	strSlice = append(strSlice, "hello")
	strSlice = append(strSlice, "world")

	fmt.Println(strSlice)

}

package main

import "fmt"

func main() {

strSlice := make([]string, 1) // we make a slice & initialize with one item

strSlice = append(strSlice, "hello")

strSlice = append(strSlice, "world")

fmt.Println(strSlice)

}

Maps:

Maps are what we call “Hashes”, “Dictionaries” or “Associative Arrays” in misc other languages. Maps are in reality key value pairs. We use make() to create maps of certain types. Example follows –

package main

import "fmt"

func main() {

	ages := make(map[string]int) // create a map with string keys and integer values

	ages["voldemort"] = 50
	ages["thedoctor"] = 1200

	fmt.Println(ages)

}

package main

import "fmt"

func main() {

ages := make(map[string]int) // create a map with string keys and integer values

ages["voldemort"] = 50

ages["thedoctor"] = 1200

fmt.Println(ages)

}

Iteration with Range

“range” allows us to iterate over a number of data structures. range gives us the key and value in each iteration. It works quite like the “enumerate” function in some languages (eg. Python). Let’s see how we can iterate over common data structures:

package main

import "fmt"

func main() {

	// Arrays
	nums := [5]int{1, 2, 3, 4, 5}
	for index, value := range nums {
		fmt.Println(index, ": ", value)
	}

    // Maps
    emails := make(map[string]string)
    emails["gmail"] = "masnun [at] gmail.com"
    emails["work"] = "masnun [at] team.okdo.it"

    for key, value := range emails {
        fmt.Println(key, ": ", value)
    }

}

package main

import "fmt"

func main() {

// Arrays

nums := [5]int{1, 2, 3, 4, 5}

for index, value := range nums {

fmt.Println(index, ": ", value)

}

// Maps

emails := make(map[string]string)

emails["gmail"] = "masnun [at] gmail.com"

emails["work"] = "masnun [at] team.okdo.it"

for key, value := range emails {

fmt.Println(key, ": ", value)

}

That’s all for Part – 1. In my next blog post, I shall try to cover “If/Else” with “Structs, Functions & Methods”.

Uncategorized

Beautiful Themes for Sublime Text 3

Post author By masnun
Post date July 8, 2013
36 Comments on Beautiful Themes for Sublime Text 3

I have been using ST3 for a while now on test drive and I have checked out some of the themes currently available for Sublime Text 3. All of these themes are available via Package Control. I am also going to link the screenshots to their respective github repo in case you don’t want to use Package Control for some (weird) reasons.