GoLang is looking really promising. It's super ease of portability and almost rapid development ability is positioning itself strong in the market. I have drawn a strong interest to it for it's ability to quickly write network/operations tools, compile them on any device and send it out so easily. I'm not in a position to judge performance as I'm very new to the language, though my opinion is it's probably fast enough.
There are plenty of ways to learn GoLang so I'm not going to even try cover that here. Even though the language specification is extremely small and you can get up to speed rather quickly with a short tutorial. Instead I'm going to focus on the things, as a new person to GoLang, that I have liked the most.
go get https://github.com/golang/example will go download the GoLang package from Github and put it into your GOPATH.
import "github.com/golang/example" will then import the package to your project.
gofmt -w *.go will format your projects files, in-place, to the GoLang standard formatting. I suggest setting this up to do it when you save with your choice of editor. For VIM users, I highly recommend faith/vim-go.
The language is so simple, but has such a powerful exhaustive standard library that includes so many powerful tools. Check out how easy it is to make a Basic Web Server
Variable assignment can automatically infer type or you can explicitly define. This gives you almost the luxury of a Dynamic language with the power of a Static language.
var height int = 186 // Explicit Assignment height := 100 // Short assignment, only use in local scoped variables.
Unused variables results in a compiler error, this helps keep code very clean and concise when refactoring and working in large code bases.
Strings can be concatenated with the + operator. A small... lovely... luxury.
i:= 0 i++
Looking at you Ruby.
numbers := []int {1,2,3,4,5}
for _, number := range numbers {
fmt.Println(number)
}
This gives a really quick and nice way for iterating through collections and just to me looks very concise and neat. The _ idiom for discarding the index, to me can sometimes be annoying.
age, height := getDetails()
func getDetails() (int, int) {
return 26, 186
}
func collectionOfInts(args ... int) {
for _, number {
...
}
}
Goroutines are very lightweight Threads, that aren't really threads. They require alot less memory then threads in other languages. The idea is that GoLang maintains a pool of OS thread's in the runtime, allocating Goroutines to them so the OS is not aware of what your program is doing. This allows quick and cheap switching, easily ignore blocking calls from locking a Thread; without the cost of them.
While you will need to consider syncing variables as they are in the same memory space, creating a go routine is extremely simple; prefix a function with go
func main() {
go printStuff() // new goroutine
printStuff() // in main goroutine
}
func printStuff() {
... // Print things
}
go func(number int) {
for i := 0; i < number; i++ {
fmt.Println(i)
}
}(6)
GoLang does not use public/private keywords for visibility identifiers. If the first letter is a capital, it is public, lower case is private. This applies for variables, methods constants etc.
struct Person {
age int // private
Height int // public
} // Public Struct in package.
I develop on two main machines, a Macbook and a Linux desktop. A compiled language has always been a concern about ease of use between different platforms. While cross compilation isn't a new thing, I haven't experienced anything as easy as the way Go 1.5+ does it.
This gives me a quick build for my Raspberry Pi
GOOS=linux GOARCH=arm GOARM=7 go build
This gives me a quick build for my Windows friend
GOOS=windows go build
Or a quick file to run on any of my Linux servers
GOOS=linux go build
Please sign in to post comments…