Object Oriented Go

Because Go doesn't have classes some have concluded that it's not an object oriented language. This is simply not true. I thought I'd share a simple problem that I needed to solve in Go in an object oriented way. Note that this won't demonstrate all of it's object oriented capabilities but it shows how one can create simple objects with methods.

When writing code I've frequently used a technique for poor mans profiling where you start a timer, perform a set of operations and then see how much time has elapsed. This technique is not a substitute for real profiling tools like valgrind, but it sometimes is handy and sufficient. In C++ or Java I'd create a Timer class that will get the current time when it's constructed and then add an elapsed() method which will return how many nano/milli seconds have passed since the object was constructed. I needed this for a Go project I'm working on and this is how I did it:

First of all I define a new type.

	// A simple timer
	type Timer time.Time

view raw TimerType.go hosted with ❤ by GitHub

This code defines a new type Timer that will have the same representation in memory as the time.Time structure but it's treated as a new type by the type checker. This means that if you try to call a time.Time method on a Timer object you'll get a compiler error. You can however convert a time.Time to a Timer and vice-versa by type casting.

Now that we have a new type lets create a function for creating a new Timer. In Java we'd probably call this method timerFactory, but will just call it StartTimer().

	// Create and start a new timer
	func StartTimer() Timer {
	return Timer(time.Now())
	}

view raw StartTimer.go hosted with ❤ by GitHub

The time.Now() call returns a new time.Time object representing the current date and time, which we then type cast to a Timer and return it.

Now we want to add a method to our Timer object that will return the number of nanoseconds that have elapsed since the Timer was created.

	// Return the number of nanoseconds that have elapsed.
	func (t Timer) ElapsedNanoseconds() int64 {
	return time.Now().Sub(time.Time(t)).Nanoseconds()
	}

view raw TimerElapsedNanoseconds.go hosted with ❤ by GitHub

The ElapsedNanoseconds() method gets the new date and time with time.Now() and subtracts the original time. We must cast the Timer to time.Time because it's a different type, and then we return the number of nanoseconds that have elapsed.

We can now use our new Timer type as follows:

	timer := StartTimer()
	time.Sleep(100000000)
	print(timer.ElapsesNanoseconds(), "\n")

view raw TimerExample.go hosted with ❤ by GitHub

That's it! This works great as is but sometimes you don't need nanosecond resolution, millisecond resolution might be just fine. So lets add a new method to our Timer type to get the elapsed time in milliseconds instead.

	// Return the number of milliseconds that have elapsed.
	func (t Timer) ElapsedMilliseconds() int64 {
	return t.ElapsedNanoseconds() / 1000000
	}

view raw ElapsedMilliseconds.go hosted with ❤ by GitHub

While this code works perfectly fine, the code will make it easy for us to write a bug. Consider the following:

	timer0 := StartTimer()
	time.Sleep(1000000000) // Sleep for one second
	shortDelay := timer0.ElapsedNanoseconds()
	timer1 := StartTimer()
	time.Sleep(2 * 1000000000) // Sleep for two seconds
	longDelay := timer1.ElapsedMilliseconds()
	if shortDelay > longDelay {
	fmt.Print("Something bad happened\n")
	}

view raw TimerBug.go hosted with ❤ by GitHub

This code creates two Timer objects and attempts to compare the elapsed time between them. Unfortunately the units on the shortDelay are nanoseconds and the units on the longDelay are milliseconds. Comparing these values this way would make our High School Algebra teachers sad. Luckily we can fix this by defining new types for the nanosecond and millisecond delays.

	// A simple timer for seeing how long an operation lasts
	type Timer time.Time
	// Create and start a new timer
	func StartTimer() Timer {
	return Timer(time.Now())
	}
	// A Nanosecond time value
	type Nanosecond int64
	// Return the number of nanoseconds that have elapsed.
	func (t Timer) ElapsedNanoseconds() Nanosecond {
	return Nanosecond(time.Now().Sub(time.Time(t)).Nanoseconds())
	}
	// A Millisecond time value
	type Millisecond int64
	// Return the number of milliseconds that have elapsed.
	func (t Timer) ElapsedMilliseconds() Millisecond {
	return Millisecond(t.ElapsedNanoseconds() / 1000000)
	}

view raw TypeSafeTimer.go hosted with ❤ by GitHub

We defined two new types Nanosecond and Millisecond. Each are based off of int64 so they'll have the same memory layout as an int64, but they're treated as different types by Go's type system. Now if we try and write code to compare these values we get an error message like "invalid operation: shortDelay > longDelay (mismatched types Nanosecond and Millisecond)". We're using the type system to enforce units on time! Now wouldn't it be nice to be able to convert from a Nanosecond to a Millisecond? We can do that by adding conversion methods to the Nanosecond and Millisecond types.

	// Convert Nanoseconds to Milliseconds
	func (n Nanosecond) ToMilliseconds() Millisecond {
	return Millisecond(n / 1000000)
	}
	// Convert Milliseconds to Nanoseconds
	func (m Millisecond) ToNanoseconds() Nanosecond {
	return Nanosecond(m * 1000000)
	}

view raw NanoToMilli.go hosted with ❤ by GitHub

We can now fix our buggy use of Timer like so.

	timer0 := StartTimer()
	time.Sleep(1000000000) // Sleep for one second
	shortDelay := timer0.ElapsedNanoseconds()
	timer1 := StartTimer()
	time.Sleep(2 * 1000000000) // Sleep for two seconds
	longDelay := timer1.ElapsedMilliseconds()
	if shortDelay.ToMilliseconds() > longDelay {
	fmt.Print("Something bad happened\n")
	}

view raw FixedTimerBug.go hosted with ❤ by GitHub

That's it! We created three new types Timer, Millisecond, Nanosecond (they would be classes in C++/Java) and one factory function and three new methods. The full code with the example usage can be downloaded and executed by typing "go run main.go".

	package main
	import (
	"fmt"
	"time"
	)
	// A simple timer
	type Timer time.Time
	// Create and start a new timer
	func StartTimer() Timer {
	return Timer(time.Now())
	}
	// A Nanosecond time value
	type Nanosecond int64
	// Return the number of nanoseconds that have elapsed.
	func (t Timer) ElapsedNanoseconds() Nanosecond {
	return Nanosecond(time.Now().Sub(time.Time(t)).Nanoseconds())
	}
	// A Millisecond time value
	type Millisecond int64
	// Return the number of milliseconds that have elapsed.
	func (t Timer) ElapsedMilliseconds() Millisecond {
	return Millisecond(t.ElapsedNanoseconds() / 1000000)
	}
	// Convert Nanoseconds to Milliseconds
	func (n Nanosecond) ToMilliseconds() Millisecond {
	return Millisecond(n / 1000000)
	}
	// Convert Milliseconds to Nanoseconds
	func (m Millisecond) ToNanoseconds() Nanosecond {
	return Nanosecond(m * 1000000)
	}
	func main() {
	timer0 := StartTimer()
	time.Sleep(1000000000) // Sleep for one second
	shortDelay := timer0.ElapsedNanoseconds()
	timer1 := StartTimer()
	time.Sleep(2 * 1000000000) // Sleep for two seconds
	longDelay := timer1.ElapsedMilliseconds()
	if shortDelay.ToMilliseconds() > longDelay {
	fmt.Print("Something bad happened\n")
	}
	fmt.Print("Bubye!\n")
	}

view raw main.go hosted with ❤ by GitHub