Author: masnun

Vim Madness

I use the top notch IDEs for development but that is not geeky enough. So, ignoring my previous failed attempts, I am going to give the text editor one more try. Apparently, this blog post would be more like self documentation, mostly notes and hints to self. If anyone else also gets benefited, that’d be an added bonus.

Quick Shortcuts

Vundle Bundle Installation: “:BundleInstall”
New Tab: “:tabnew ”
Navigate Tabs: “:tabn” for next, “:tabp” for prev. “gt” in normal mode
Switch Windows: “Ctrl + w, Ctrl+w”
Splitting Windows: “:split “, “vsplit” for vertical splits
NerdTree – Open in new tab: “t”

Let there be ~/.vimrc

OK, here’s my ~/.vimrc, the initial version is messy, not organized at all, everything I came across, I stuffed in here. I shall update and clean the vimrc over time.

Uncategorized

Go: Creating new types based on built-in types

Post author By masnun
Post date August 6, 2013

Ever needed a custom string type to add your own methods or tweak certain behavior? In languages like Ruby or Javascript, you can directly modify built in types. In other languages, we usually create custom objects to wrap around a default type and then extend that object with necessary methods or attributes.

A sample example in Python would look like:

class MyString(object):

    def __init__(self, val):
        self.val = val

    def print_len(self):
        print "Length: " + str(len(self.val))

name = MyString("masnun")
name.print_len()

class MyString(object):

def __init__(self, val):

self.val = val

def print_len(self):

print "Length: " + str(len(self.val))

name = MyString("masnun")

name.print_len()

In Go, we would define a new type based on an existing type. Then define methods on the newly defined type. It allows us to easily create new types based on existing types and then customize to suit our needs. The same example in Go would look like:

package main

import (
    "fmt"
)

// create custom_string type based on built in string
type custom_string string

// method definition - the function "receives" a custom_string type and
// acts on the type

func (str custom_string) PrintLen() {
    fmt.Printf("Length: %d \n", len(str))
}

func main() {

    // define a new variable of our new type
    var name custom_string = "Masnun"
    // call the custom method
    name.PrintLen()

}

package main

import (

"fmt"

)

// create custom_string type based on built in string

type custom_string string

// method definition - the function "receives" a custom_string type and

// acts on the type

func (str custom_string) PrintLen() {

fmt.Printf("Length: %d \n", len(str))

}

func main() {

// define a new variable of our new type

var name custom_string = "Masnun"

// call the custom method

name.PrintLen()

}

Simple, isn’t it?

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.

Recent Posts

Recent Comments

Archives

Categories